| Directory: | ./ |
|---|---|
| File: | sql/item_func.cc |
| Date: | 2022-12-13 11:44:05 |
| Exec | Total | Coverage | |
|---|---|---|---|
| Lines: | 5042 | 5384 | 93.6% |
| Branches: | 4294 | 6407 | 67.0% |
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* Copyright (c) 2000, 2022, Oracle and/or its affiliates. | ||
| 2 | |||
| 3 | This program is free software; you can redistribute it and/or modify | ||
| 4 | it under the terms of the GNU General Public License, version 2.0, | ||
| 5 | as published by the Free Software Foundation. | ||
| 6 | |||
| 7 | This program is also distributed with certain software (including | ||
| 8 | but not limited to OpenSSL) that is licensed under separate terms, | ||
| 9 | as designated in a particular file or component or in included license | ||
| 10 | documentation. The authors of MySQL hereby grant you an additional | ||
| 11 | permission to link the program and your derivative works with the | ||
| 12 | separately licensed software that they have included with MySQL. | ||
| 13 | |||
| 14 | This program is distributed in the hope that it will be useful, | ||
| 15 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 17 | GNU General Public License, version 2.0, for more details. | ||
| 18 | |||
| 19 | You should have received a copy of the GNU General Public License | ||
| 20 | along with this program; if not, write to the Free Software | ||
| 21 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ | ||
| 22 | |||
| 23 | /** | ||
| 24 | @file | ||
| 25 | |||
| 26 | @brief | ||
| 27 | This file defines all numerical Items | ||
| 28 | */ | ||
| 29 | |||
| 30 | #include "sql/item_func.h" | ||
| 31 | |||
| 32 | #include <algorithm> | ||
| 33 | #include <atomic> | ||
| 34 | #include <cfloat> // DBL_DIG | ||
| 35 | #include <cmath> // std::log2 | ||
| 36 | #include <cstdio> | ||
| 37 | #include <cstring> | ||
| 38 | #include <ctime> | ||
| 39 | #include <initializer_list> | ||
| 40 | #include <iosfwd> | ||
| 41 | #include <limits> // std::numeric_limits | ||
| 42 | #include <memory> | ||
| 43 | #include <new> | ||
| 44 | #include <string> | ||
| 45 | #include <type_traits> | ||
| 46 | #include <unordered_map> | ||
| 47 | #include <utility> | ||
| 48 | |||
| 49 | #include "integer_digits.h" | ||
| 50 | #include "m_string.h" | ||
| 51 | #include "map_helpers.h" | ||
| 52 | #include "mutex_lock.h" // MUTEX_LOCK | ||
| 53 | #include "my_bit.h" // my_count_bits | ||
| 54 | #include "my_bitmap.h" | ||
| 55 | #include "my_byteorder.h" | ||
| 56 | #include "my_dbug.h" | ||
| 57 | #include "my_double2ulonglong.h" | ||
| 58 | #include "my_hostname.h" | ||
| 59 | #include "my_loglevel.h" | ||
| 60 | #include "my_psi_config.h" | ||
| 61 | #include "my_sqlcommand.h" | ||
| 62 | #include "my_sys.h" | ||
| 63 | #include "my_systime.h" | ||
| 64 | #include "my_thread.h" | ||
| 65 | #include "my_user.h" // parse_user | ||
| 66 | #include "mysql/components/services/bits/mysql_cond_bits.h" | ||
| 67 | #include "mysql/components/services/bits/mysql_mutex_bits.h" | ||
| 68 | #include "mysql/components/services/bits/psi_bits.h" | ||
| 69 | #include "mysql/components/services/bits/psi_mutex_bits.h" | ||
| 70 | #include "mysql/components/services/log_builtins.h" | ||
| 71 | #include "mysql/components/services/log_shared.h" | ||
| 72 | #include "mysql/mysql_lex_string.h" | ||
| 73 | #include "mysql/plugin_audit.h" | ||
| 74 | #include "mysql/psi/mysql_cond.h" | ||
| 75 | #include "mysql/psi/mysql_mutex.h" | ||
| 76 | #include "mysql/service_mysql_password_policy.h" | ||
| 77 | #include "mysql/service_thd_wait.h" | ||
| 78 | #include "mysql/status_var.h" | ||
| 79 | #include "prealloced_array.h" | ||
| 80 | #include "sql-common/json_dom.h" // Json_wrapper | ||
| 81 | #include "sql/auth/auth_acls.h" | ||
| 82 | #include "sql/auth/auth_common.h" // check_password_strength | ||
| 83 | #include "sql/auth/sql_security_ctx.h" | ||
| 84 | #include "sql/binlog.h" // mysql_bin_log | ||
| 85 | #include "sql/check_stack.h" | ||
| 86 | #include "sql/current_thd.h" // current_thd | ||
| 87 | #include "sql/dd/info_schema/table_stats.h" // dd::info_schema::Table_stati... | ||
| 88 | #include "sql/dd/info_schema/tablespace_stats.h" // dd::info_schema::Tablesp... | ||
| 89 | #include "sql/dd/object_id.h" | ||
| 90 | #include "sql/dd/properties.h" // dd::Properties | ||
| 91 | #include "sql/dd/types/abstract_table.h" | ||
| 92 | #include "sql/dd/types/column.h" | ||
| 93 | #include "sql/dd/types/index.h" // Index::enum_index_type | ||
| 94 | #include "sql/dd_sql_view.h" // push_view_warning_or_error | ||
| 95 | #include "sql/dd_table_share.h" // dd_get_old_field_type | ||
| 96 | #include "sql/debug_sync.h" // DEBUG_SYNC | ||
| 97 | #include "sql/derror.h" // ER_THD | ||
| 98 | #include "sql/error_handler.h" // Internal_error_handler | ||
| 99 | #include "sql/item.h" // Item_json | ||
| 100 | #include "sql/item_cmpfunc.h" // get_datetime_value | ||
| 101 | #include "sql/item_json_func.h" // get_json_wrapper | ||
| 102 | #include "sql/item_strfunc.h" // Item_func_concat_ws | ||
| 103 | #include "sql/item_subselect.h" // Item_subselect | ||
| 104 | #include "sql/key.h" | ||
| 105 | #include "sql/log_event.h" // server_version | ||
| 106 | #include "sql/mdl.h" | ||
| 107 | #include "sql/mysqld.h" // log_10 stage_user_sleep | ||
| 108 | #include "sql/parse_tree_helpers.h" // PT_item_list | ||
| 109 | #include "sql/parse_tree_node_base.h" // Parse_context | ||
| 110 | #include "sql/protocol.h" | ||
| 111 | #include "sql/psi_memory_key.h" | ||
| 112 | #include "sql/resourcegroups/resource_group.h" | ||
| 113 | #include "sql/resourcegroups/resource_group_basic_types.h" | ||
| 114 | #include "sql/resourcegroups/resource_group_mgr.h" | ||
| 115 | #include "sql/rpl_gtid.h" | ||
| 116 | #include "sql/rpl_mi.h" // Master_info | ||
| 117 | #include "sql/rpl_msr.h" // channel_map | ||
| 118 | #include "sql/rpl_rli.h" // Relay_log_info | ||
| 119 | #include "sql/sp.h" // sp_setup_routine | ||
| 120 | #include "sql/sp_head.h" // sp_name | ||
| 121 | #include "sql/sp_pcontext.h" // sp_variable | ||
| 122 | #include "sql/sql_array.h" // just to keep clang happy | ||
| 123 | #include "sql/sql_audit.h" // audit_global_variable | ||
| 124 | #include "sql/sql_base.h" // Internal_error_handler_holder | ||
| 125 | #include "sql/sql_bitmap.h" | ||
| 126 | #include "sql/sql_class.h" // THD | ||
| 127 | #include "sql/sql_cmd.h" | ||
| 128 | #include "sql/sql_derived.h" // Condition_pushdown | ||
| 129 | #include "sql/sql_error.h" | ||
| 130 | #include "sql/sql_exchange.h" // sql_exchange | ||
| 131 | #include "sql/sql_executor.h" | ||
| 132 | #include "sql/sql_lex.h" | ||
| 133 | #include "sql/sql_list.h" | ||
| 134 | #include "sql/sql_load.h" // Sql_cmd_load_table | ||
| 135 | #include "sql/sql_optimizer.h" // JOIN | ||
| 136 | #include "sql/sql_parse.h" // check_stack_overrun | ||
| 137 | #include "sql/sql_show.h" // append_identifier | ||
| 138 | #include "sql/sql_time.h" // TIME_from_longlong_packed | ||
| 139 | #include "sql/sql_zip_dict.h" | ||
| 140 | #include "sql/strfunc.h" // find_type | ||
| 141 | #include "sql/system_variables.h" | ||
| 142 | #include "sql/thd_raii.h" | ||
| 143 | #include "sql/val_int_compare.h" // Integer_value | ||
| 144 | #include "sql_string.h" | ||
| 145 | #include "template_utils.h" // pointer_cast | ||
| 146 | #include "thr_mutex.h" | ||
| 147 | |||
| 148 | #ifdef WITH_WSREP | ||
| 149 | #include "wsrep_trans_observer.h" | ||
| 150 | #endif /* WITH_WSREP */ | ||
| 151 | |||
| 152 | class Protocol; | ||
| 153 | class sp_rcontext; | ||
| 154 | |||
| 155 | using std::max; | ||
| 156 | using std::min; | ||
| 157 | |||
| 158 | 144956 | static void free_user_var(user_var_entry *entry) { entry->destroy(); } | |
| 159 | |||
| 160 | static int get_var_with_binlog(THD *thd, enum_sql_command sql_command, | ||
| 161 | const Name_string &name, | ||
| 162 | user_var_entry **out_entry); | ||
| 163 | |||
| 164 | 20497 | bool check_reserved_words(const char *name) { | |
| 165 | 20497 | if (!my_strcasecmp(system_charset_info, name, "GLOBAL") || | |
| 166 |
6/6✓ Branch 0 taken 20437 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 20394 times.
✓ Branch 3 taken 43 times.
✓ Branch 4 taken 116 times.
✓ Branch 5 taken 20381 times.
|
40891 | !my_strcasecmp(system_charset_info, name, "LOCAL") || |
| 167 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 20381 times.
|
20394 | !my_strcasecmp(system_charset_info, name, "SESSION")) |
| 168 | 116 | return true; | |
| 169 | 20381 | return false; | |
| 170 | } | ||
| 171 | |||
| 172 | 58 | void report_conversion_error(const CHARSET_INFO *to_cs, const char *from, | |
| 173 | size_t from_length, const CHARSET_INFO *from_cs) { | ||
| 174 | char printable_buff[32]; | ||
| 175 |
1/2✓ Branch 0 taken 58 times.
✗ Branch 1 not taken.
|
58 | convert_to_printable(printable_buff, sizeof(printable_buff), from, |
| 176 | from_length, from_cs, 6); | ||
| 177 | 58 | const char *from_name = from_cs->csname; | |
| 178 | 58 | const char *to_name = to_cs->csname; | |
| 179 |
1/2✓ Branch 0 taken 58 times.
✗ Branch 1 not taken.
|
58 | my_error(ER_CANNOT_CONVERT_STRING, MYF(0), printable_buff, from_name, |
| 180 | to_name); | ||
| 181 | 58 | } | |
| 182 | |||
| 183 | /** | ||
| 184 | Simplify the string arguments to a function, if possible. | ||
| 185 | |||
| 186 | Currently used to substitute const values with character strings | ||
| 187 | in the desired character set. Only used during resolving. | ||
| 188 | |||
| 189 | @param thd thread handler | ||
| 190 | @param c Desired character set and collation | ||
| 191 | @param args Pointer to argument array | ||
| 192 | @param nargs Number of arguments to process | ||
| 193 | |||
| 194 | @returns false if success, true if error | ||
| 195 | */ | ||
| 196 | 605285 | bool simplify_string_args(THD *thd, const DTCollation &c, Item **args, | |
| 197 | uint nargs) { | ||
| 198 | // Only used during resolving | ||
| 199 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 605285 times.
|
605285 | assert(!thd->lex->is_exec_started()); |
| 200 | |||
| 201 |
2/2✓ Branch 0 taken 97087 times.
✓ Branch 1 taken 508198 times.
|
605285 | if (thd->lex->is_view_context_analysis()) return false; |
| 202 | |||
| 203 | uint i; | ||
| 204 | Item **arg; | ||
| 205 |
2/2✓ Branch 0 taken 508364 times.
✓ Branch 1 taken 508197 times.
|
1016561 | for (i = 0, arg = args; i < nargs; i++, arg++) { |
| 206 | size_t dummy_offset; | ||
| 207 | // Only convert const values. | ||
| 208 |
3/4✓ Branch 0 taken 508364 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 27334 times.
✓ Branch 3 taken 481030 times.
|
979749 | if (!(*arg)->const_item()) continue; |
| 209 |
3/4✓ Branch 0 taken 481030 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 471383 times.
✓ Branch 3 taken 9647 times.
|
481030 | if (!String::needs_conversion(1, (*arg)->collation.collation, c.collation, |
| 210 | &dummy_offset)) | ||
| 211 | 471383 | continue; | |
| 212 | |||
| 213 | 9647 | StringBuffer<STRING_BUFFER_USUAL_SIZE> original; | |
| 214 | 9647 | StringBuffer<STRING_BUFFER_USUAL_SIZE> converted; | |
| 215 |
1/2✓ Branch 0 taken 9647 times.
✗ Branch 1 not taken.
|
9647 | String *ostr = (*arg)->val_str(&original); |
| 216 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 9645 times.
|
9647 | if (ostr == nullptr) { |
| 217 |
2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
2 | if (thd->is_error()) return true; |
| 218 |
2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
2 | *arg = new (thd->mem_root) Item_null; |
| 219 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (*arg == nullptr) return true; |
| 220 | 2 | continue; | |
| 221 | } | ||
| 222 | uint conv_status; | ||
| 223 |
1/2✓ Branch 0 taken 9645 times.
✗ Branch 1 not taken.
|
9645 | converted.copy(ostr->ptr(), ostr->length(), ostr->charset(), c.collation, |
| 224 | &conv_status); | ||
| 225 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 9644 times.
|
9645 | if (conv_status != 0) { |
| 226 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | report_conversion_error(c.collation, ostr->ptr(), ostr->length(), |
| 227 | ostr->charset()); | ||
| 228 | 1 | return true; | |
| 229 | } | ||
| 230 | // If source is a binary string, the string may have to be validated: | ||
| 231 |
3/6✓ Branch 0 taken 9644 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9644 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 9644 times.
|
9644 | if (c.collation != &my_charset_bin && ostr->charset() == &my_charset_bin && |
| 232 | ✗ | !converted.is_valid_string(c.collation)) { | |
| 233 | ✗ | report_conversion_error(c.collation, ostr->ptr(), ostr->length(), | |
| 234 | ostr->charset()); | ||
| 235 | ✗ | return true; | |
| 236 | } | ||
| 237 | |||
| 238 |
1/2✓ Branch 0 taken 9644 times.
✗ Branch 1 not taken.
|
9644 | char *ptr = thd->strmake(converted.ptr(), converted.length()); |
| 239 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9644 times.
|
9644 | if (ptr == nullptr) return true; |
| 240 | Item *conv = new (thd->mem_root) | ||
| 241 |
2/4✓ Branch 0 taken 9644 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9644 times.
✗ Branch 3 not taken.
|
9644 | Item_string(ptr, converted.length(), converted.charset(), c.derivation); |
| 242 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9644 times.
|
9644 | if (conv == nullptr) return true; |
| 243 | |||
| 244 | 9644 | *arg = conv; | |
| 245 | |||
| 246 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9644 times.
|
9644 | assert(conv->fixed); |
| 247 |
6/6✓ Branch 0 taken 9644 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 9644 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 1 times.
|
9650 | } |
| 248 | 508197 | return false; | |
| 249 | } | ||
| 250 | |||
| 251 | /** | ||
| 252 | Evaluate an argument string and return it in the desired character set. | ||
| 253 | Perform character set conversion if needed. | ||
| 254 | Perform character set validation (from a binary string) if needed. | ||
| 255 | |||
| 256 | @param to_cs The desired character set | ||
| 257 | @param arg Argument to evaluate as a string value | ||
| 258 | @param buffer String buffer where argument is evaluated, if necessary | ||
| 259 | |||
| 260 | @returns string pointer if success, NULL if error or NULL value | ||
| 261 | */ | ||
| 262 | |||
| 263 | 694973037 | String *eval_string_arg(const CHARSET_INFO *to_cs, Item *arg, String *buffer) { | |
| 264 |
1/2✓ Branch 0 taken 694973150 times.
✗ Branch 1 not taken.
|
694973037 | StringBuffer<STRING_BUFFER_USUAL_SIZE> local_string(nullptr, 0, to_cs); |
| 265 | |||
| 266 | size_t offset; | ||
| 267 | const bool convert = | ||
| 268 |
1/2✓ Branch 0 taken 694973133 times.
✗ Branch 1 not taken.
|
694973150 | String::needs_conversion(0, arg->collation.collation, to_cs, &offset); |
| 269 |
3/4✓ Branch 0 taken 1760128 times.
✓ Branch 1 taken 693213005 times.
✓ Branch 2 taken 694973089 times.
✗ Branch 3 not taken.
|
694973133 | String *res = arg->val_str(convert ? &local_string : buffer); |
| 270 | |||
| 271 | // Return immediately if argument is a NULL value, or there was an error | ||
| 272 |
2/2✓ Branch 0 taken 1687843 times.
✓ Branch 1 taken 693285246 times.
|
694973089 | if (res == nullptr) { |
| 273 | 1687843 | return nullptr; | |
| 274 | } | ||
| 275 |
2/2✓ Branch 0 taken 1759797 times.
✓ Branch 1 taken 691525449 times.
|
693285246 | if (convert) { |
| 276 | /* | ||
| 277 | String must be converted from source character set. It has been built | ||
| 278 | in the "local_string" buffer and will be copied with conversion into the | ||
| 279 | caller provided buffer. | ||
| 280 | */ | ||
| 281 | 1759797 | uint errors = 0; | |
| 282 | 1759797 | buffer->length(0); | |
| 283 |
1/2✓ Branch 0 taken 1759801 times.
✗ Branch 1 not taken.
|
1759802 | buffer->copy(res->ptr(), res->length(), res->charset(), to_cs, &errors); |
| 284 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1759796 times.
|
1759801 | if (errors) { |
| 285 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | report_conversion_error(to_cs, res->ptr(), res->length(), res->charset()); |
| 286 | 5 | return nullptr; | |
| 287 | } | ||
| 288 | 1759796 | return buffer; | |
| 289 | } | ||
| 290 | // If source is a binary string, the string may have to be validated: | ||
| 291 |
6/6✓ Branch 0 taken 691280072 times.
✓ Branch 1 taken 245377 times.
✓ Branch 2 taken 739390 times.
✓ Branch 3 taken 690540682 times.
✓ Branch 4 taken 31 times.
✓ Branch 5 taken 691525418 times.
|
692264839 | if (to_cs != &my_charset_bin && arg->collation.collation == &my_charset_bin && |
| 292 |
3/4✓ Branch 0 taken 739390 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
✓ Branch 3 taken 739359 times.
|
739390 | !res->is_valid_string(to_cs)) { |
| 293 |
1/2✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
|
31 | report_conversion_error(to_cs, res->ptr(), res->length(), res->charset()); |
| 294 | 31 | return nullptr; | |
| 295 | } | ||
| 296 | // Adjust target character set to the desired value | ||
| 297 | 691525418 | res->set_charset(to_cs); | |
| 298 | 691525377 | return res; | |
| 299 | 694973052 | } | |
| 300 | |||
| 301 | /** | ||
| 302 | Evaluate a constant condition, represented by an Item tree | ||
| 303 | |||
| 304 | @param thd Thread handler | ||
| 305 | @param cond The constant condition to evaluate | ||
| 306 | @param[out] value Returned value, either true or false | ||
| 307 | |||
| 308 | @returns false if evaluation is successful, true otherwise | ||
| 309 | */ | ||
| 310 | |||
| 311 | 54817 | bool eval_const_cond(THD *thd, Item *cond, bool *value) { | |
| 312 | // Function may be used both during resolving and during optimization: | ||
| 313 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 54817 times.
|
54817 | assert(cond->may_evaluate_const(thd)); |
| 314 | 54817 | *value = cond->val_bool(); | |
| 315 | 54817 | return thd->is_error(); | |
| 316 | } | ||
| 317 | |||
| 318 | /** | ||
| 319 | Test if the sum of arguments overflows the ulonglong range. | ||
| 320 | */ | ||
| 321 | 5883213 | static inline bool test_if_sum_overflows_ull(ulonglong arg1, ulonglong arg2) { | |
| 322 | 5883213 | return ULLONG_MAX - arg1 < arg2; | |
| 323 | } | ||
| 324 | |||
| 325 | 4618664 | bool Item_func::set_arguments(mem_root_deque<Item *> *list, bool context_free) { | |
| 326 | 4618664 | allowed_arg_cols = 1; | |
| 327 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4618667 times.
|
4618664 | if (alloc_args(*THR_MALLOC, list->size())) return true; |
| 328 | 4618667 | std::copy(list->begin(), list->end(), args); | |
| 329 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 4618649 times.
|
4618676 | if (!context_free) { |
| 330 |
3/4✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 27 times.
|
92 | for (const Item *arg : make_array(args, arg_count)) { |
| 331 | 65 | add_accum_properties(arg); | |
| 332 | } | ||
| 333 | } | ||
| 334 | 4618676 | list->clear(); // Fields are used | |
| 335 | 4618665 | return false; | |
| 336 | } | ||
| 337 | |||
| 338 | 4460380 | Item_func::Item_func(const POS &pos, PT_item_list *opt_list) | |
| 339 | 4460380 | : Item_result_field(pos), allowed_arg_cols(1) { | |
| 340 |
2/2✓ Branch 0 taken 90990 times.
✓ Branch 1 taken 4369404 times.
|
4460394 | if (opt_list == nullptr) { |
| 341 | 90990 | args = m_embedded_arguments; | |
| 342 | 90990 | arg_count = 0; | |
| 343 | } else | ||
| 344 |
1/2✓ Branch 0 taken 4369396 times.
✗ Branch 1 not taken.
|
4369404 | set_arguments(&opt_list->value, true); |
| 345 | 4460386 | } | |
| 346 | |||
| 347 | 1464338 | Item_func::Item_func(THD *thd, const Item_func *item) | |
| 348 | : Item_result_field(thd, item), | ||
| 349 | 1464354 | null_on_null(item->null_on_null), | |
| 350 | 1464354 | allowed_arg_cols(item->allowed_arg_cols), | |
| 351 | 1464354 | used_tables_cache(item->used_tables_cache), | |
| 352 | 1464338 | not_null_tables_cache(item->not_null_tables_cache) { | |
| 353 |
2/4✓ Branch 0 taken 1464358 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1464358 times.
|
1464354 | if (alloc_args(thd->mem_root, item->arg_count)) return; |
| 354 |
1/2✓ Branch 0 taken 1464354 times.
✗ Branch 1 not taken.
|
1464358 | std::copy_n(item->args, arg_count, args); |
| 355 | } | ||
| 356 | |||
| 357 | 31330627 | bool Item_func::itemize(Parse_context *pc, Item **res) { | |
| 358 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 31330686 times.
|
31330627 | if (skip_itemize(res)) return false; |
| 359 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31330798 times.
|
31330686 | if (Item_result_field::itemize(pc, res)) return true; |
| 360 | 31330798 | const bool no_named_params = !may_have_named_parameters(); | |
| 361 |
2/2✓ Branch 0 taken 72179148 times.
✓ Branch 1 taken 31330549 times.
|
103509697 | for (size_t i = 0; i < arg_count; i++) { |
| 362 | 72179148 | add_accum_properties(args[i]); | |
| 363 |
2/2✓ Branch 0 taken 204 times.
✓ Branch 1 taken 72179045 times.
|
72179142 | if (args[i]->itemize(pc, &args[i])) return true; |
| 364 |
6/6✓ Branch 0 taken 72153934 times.
✓ Branch 1 taken 25111 times.
✓ Branch 2 taken 43 times.
✓ Branch 3 taken 72153891 times.
✓ Branch 4 taken 43 times.
✓ Branch 5 taken 72179002 times.
|
72179045 | if (no_named_params && !args[i]->item_name.is_autogenerated()) { |
| 365 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 41 times.
|
43 | my_error(functype() == FUNC_SP ? ER_WRONG_PARAMETERS_TO_STORED_FCT |
| 366 | : ER_WRONG_PARAMETERS_TO_NATIVE_FCT, | ||
| 367 | 43 | MYF(0), func_name()); | |
| 368 | 43 | return true; | |
| 369 | } | ||
| 370 | } | ||
| 371 | 31330549 | return false; | |
| 372 | } | ||
| 373 | |||
| 374 | /* | ||
| 375 | Resolve references to table column for a function and its argument | ||
| 376 | |||
| 377 | SYNOPSIS: | ||
| 378 | fix_fields() | ||
| 379 | thd Thread object | ||
| 380 | |||
| 381 | DESCRIPTION | ||
| 382 | Call fix_fields() for all arguments to the function. The main intention | ||
| 383 | is to allow all Item_field() objects to setup pointers to the table fields. | ||
| 384 | |||
| 385 | Sets as a side effect the following class variables: | ||
| 386 | maybe_null Set if any argument may return NULL | ||
| 387 | used_tables_cache Set to union of the tables used by arguments | ||
| 388 | |||
| 389 | str_value.charset If this is a string function, set this to the | ||
| 390 | character set for the first argument. | ||
| 391 | If any argument is binary, this is set to binary | ||
| 392 | |||
| 393 | If for any item any of the defaults are wrong, then this can | ||
| 394 | be fixed in the resolve_type() function that is called after this one or | ||
| 395 | by writing a specialized fix_fields() for the item. | ||
| 396 | |||
| 397 | RETURN VALUES | ||
| 398 | false ok | ||
| 399 | true Got error. Stored with my_error(). | ||
| 400 | */ | ||
| 401 | |||
| 402 | 40640958 | bool Item_func::fix_fields(THD *thd, Item **) { | |
| 403 |
4/6✓ Branch 0 taken 3 times.
✓ Branch 1 taken 40640955 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3 times.
|
40640958 | assert(fixed == 0 || basic_const_item()); |
| 404 | |||
| 405 | Item **arg, **arg_end; | ||
| 406 | uchar buff[STACK_BUFF_ALLOC]; // Max argument in function | ||
| 407 | |||
| 408 | 40640958 | Condition_context CCT(thd->lex->current_query_block()); | |
| 409 | |||
| 410 |
1/2✓ Branch 0 taken 40641023 times.
✗ Branch 1 not taken.
|
40641041 | used_tables_cache = get_initial_pseudo_tables(); |
| 411 | 40641023 | not_null_tables_cache = 0; | |
| 412 | |||
| 413 | /* | ||
| 414 | Use stack limit of STACK_MIN_SIZE * 2 since | ||
| 415 | on some platforms a recursive call to fix_fields | ||
| 416 | requires more than STACK_MIN_SIZE bytes (e.g. for | ||
| 417 | MIPS, it takes about 22kB to make one recursive | ||
| 418 | call to Item_func::fix_fields()) | ||
| 419 | */ | ||
| 420 |
3/4✓ Branch 0 taken 40641162 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 40641161 times.
|
40641023 | if (check_stack_overrun(thd, STACK_MIN_SIZE * 2, buff)) |
| 421 | 1 | return true; // Fatal error if flag is set! | |
| 422 |
2/2✓ Branch 0 taken 39047563 times.
✓ Branch 1 taken 1593598 times.
|
40641161 | if (arg_count) { // Print purify happy |
| 423 |
2/2✓ Branch 0 taken 93549131 times.
✓ Branch 1 taken 39042553 times.
|
132591684 | for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) { |
| 424 |
3/4✓ Branch 0 taken 93549070 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4949 times.
✓ Branch 3 taken 93544121 times.
|
93549131 | if (fix_func_arg(thd, arg)) return true; |
| 425 | } | ||
| 426 | } | ||
| 427 | |||
| 428 |
8/10✓ Branch 0 taken 40636115 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 40635657 times.
✓ Branch 3 taken 458 times.
✓ Branch 4 taken 40635660 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 8 times.
✓ Branch 7 taken 40635652 times.
✓ Branch 8 taken 512 times.
✓ Branch 9 taken 40635606 times.
|
40636151 | if (resolve_type(thd) || thd->is_error()) // Some impls still not error-safe |
| 429 | 512 | return true; | |
| 430 | 40635606 | fixed = true; | |
| 431 | 40635606 | return false; | |
| 432 | 40641068 | } | |
| 433 | |||
| 434 | 93551725 | bool Item_func::fix_func_arg(THD *thd, Item **arg) { | |
| 435 |
6/6✓ Branch 0 taken 50108778 times.
✓ Branch 1 taken 43442947 times.
✓ Branch 2 taken 4861 times.
✓ Branch 3 taken 50103862 times.
✓ Branch 4 taken 4861 times.
✓ Branch 5 taken 93546809 times.
|
93551725 | if ((!(*arg)->fixed && (*arg)->fix_fields(thd, arg))) |
| 436 | 4861 | return true; /* purecov: inspected */ | |
| 437 | 93546809 | Item *item = *arg; | |
| 438 | |||
| 439 |
2/2✓ Branch 0 taken 81342406 times.
✓ Branch 1 taken 12204403 times.
|
93546809 | if (allowed_arg_cols) { |
| 440 |
2/2✓ Branch 0 taken 88 times.
✓ Branch 1 taken 81342306 times.
|
81342406 | if (item->check_cols(allowed_arg_cols)) return true; |
| 441 | } else { | ||
| 442 | /* we have to fetch allowed_arg_cols from first argument */ | ||
| 443 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12204403 times.
|
12204403 | assert(arg == args); // it is first argument |
| 444 | 12204403 | allowed_arg_cols = item->cols(); | |
| 445 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12204527 times.
|
12204527 | assert(allowed_arg_cols); // Can't be 0 any more |
| 446 | } | ||
| 447 | |||
| 448 |
4/4✓ Branch 0 taken 74921169 times.
✓ Branch 1 taken 18625609 times.
✓ Branch 2 taken 15965670 times.
✓ Branch 3 taken 58955597 times.
|
93546833 | set_nullable(is_nullable() || item->is_nullable()); |
| 449 | 93546830 | used_tables_cache |= item->used_tables(); | |
| 450 |
2/2✓ Branch 0 taken 67665383 times.
✓ Branch 1 taken 25881448 times.
|
93546831 | if (null_on_null) not_null_tables_cache |= item->not_null_tables(); |
| 451 | 93546810 | add_accum_properties(item); | |
| 452 | |||
| 453 | 93546836 | return false; | |
| 454 | } | ||
| 455 | |||
| 456 | 25102282 | void Item_func::fix_after_pullout(Query_block *parent_query_block, | |
| 457 | Query_block *removed_query_block) { | ||
| 458 |
2/2✓ Branch 0 taken 398916 times.
✓ Branch 1 taken 24703367 times.
|
25102282 | if (const_item()) { |
| 459 | /* | ||
| 460 | Pulling out a const item changes nothing to it. Moreover, some items may | ||
| 461 | have decided that they're const by some other logic than the generic | ||
| 462 | one below, and we must preserve that decision. | ||
| 463 | */ | ||
| 464 | 398916 | return; | |
| 465 | } | ||
| 466 | |||
| 467 | Item **arg, **arg_end; | ||
| 468 | |||
| 469 | 24703367 | used_tables_cache = get_initial_pseudo_tables(); | |
| 470 | 24703367 | not_null_tables_cache = 0; | |
| 471 | |||
| 472 |
2/2✓ Branch 0 taken 24695609 times.
✓ Branch 1 taken 7758 times.
|
24703367 | if (arg_count) { |
| 473 |
2/2✓ Branch 0 taken 66437622 times.
✓ Branch 1 taken 24695567 times.
|
91133189 | for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) { |
| 474 | 66437622 | Item *const item = *arg; | |
| 475 | 66437622 | item->fix_after_pullout(parent_query_block, removed_query_block); | |
| 476 | 66437620 | used_tables_cache |= item->used_tables(); | |
| 477 |
2/2✓ Branch 0 taken 24197092 times.
✓ Branch 1 taken 42240501 times.
|
66437593 | if (null_on_null) not_null_tables_cache |= item->not_null_tables(); |
| 478 | } | ||
| 479 | } | ||
| 480 | } | ||
| 481 | |||
| 482 | /** | ||
| 483 | Default implementation for all functions: | ||
| 484 | Propagate base_item's type into all arguments. | ||
| 485 | |||
| 486 | The functions that have context-aware parameter type detection must | ||
| 487 | implement Item::default_data_type() and Item::resolve_type_inner(). | ||
| 488 | |||
| 489 | If an SQL function or operator F embeds another SQL function or | ||
| 490 | operator G: F::fix_fields() runs and calls G::fix_fields() which calls | ||
| 491 | G::resolve_type(); assuming that G is outer-context dependent and has only | ||
| 492 | dynamic parameters as arguments, G misses type information and thus does a | ||
| 493 | no-op resolve_type(); then F::fix_fields() continues and calls | ||
| 494 | F::resolve_type() which sees that G::data_type() == MYSQL_TYPE_INVALID; | ||
| 495 | F thus calls G::propagate_type() to send it the necessary type | ||
| 496 | information (i.e. provide the outer context); this then assigns the type | ||
| 497 | to dynamic parameters of G and finishes the job of G::resolve_type() by | ||
| 498 | calling G::resolve_type_inner(). | ||
| 499 | */ | ||
| 500 | 62 | bool Item_func::propagate_type(THD *thd, const Type_properties &type) { | |
| 501 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
|
62 | assert(data_type() == MYSQL_TYPE_INVALID); |
| 502 |
2/2✓ Branch 0 taken 139 times.
✓ Branch 1 taken 62 times.
|
201 | for (uint i = 0; i < arg_count; i++) { |
| 503 |
2/2✓ Branch 0 taken 124 times.
✓ Branch 1 taken 15 times.
|
139 | if (args[i]->data_type() == MYSQL_TYPE_INVALID) |
| 504 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 124 times.
|
124 | if (args[i]->propagate_type(thd, type)) return true; |
| 505 | } | ||
| 506 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 61 times.
|
62 | if (resolve_type_inner(thd)) return true; |
| 507 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | assert(data_type() != MYSQL_TYPE_INVALID); |
| 508 | |||
| 509 | 61 | return false; | |
| 510 | } | ||
| 511 | |||
| 512 | /** | ||
| 513 | For arguments of this Item_func ("args" array), in range | ||
| 514 | [start, start+step, start+2*step,...,end[ : if they're a PS | ||
| 515 | parameter with invalid (not known) type, give them default type "def". | ||
| 516 | @param thd thread handler | ||
| 517 | @param start range's start (included) | ||
| 518 | @param end range's end (excluded) | ||
| 519 | @param step range's step | ||
| 520 | @param def default type | ||
| 521 | |||
| 522 | @returns false if success, true if error | ||
| 523 | */ | ||
| 524 | 22599468 | bool Item_func::param_type_is_default(THD *thd, uint start, uint end, uint step, | |
| 525 | enum_field_types def) { | ||
| 526 |
2/2✓ Branch 0 taken 31781739 times.
✓ Branch 1 taken 17982862 times.
|
49764601 | for (uint i = start; i < end; i += step) { |
| 527 |
2/2✓ Branch 0 taken 4616611 times.
✓ Branch 1 taken 27165128 times.
|
31781739 | if (i >= arg_count) break; |
| 528 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 27165133 times.
|
27165128 | if (args[i]->propagate_type(thd, def)) return true; |
| 529 | } | ||
| 530 | 22599473 | return false; | |
| 531 | } | ||
| 532 | |||
| 533 | /** | ||
| 534 | For arguments of this Item_func ("args" array), in range [start,end[ : | ||
| 535 | sends error if they're a dynamic parameter. | ||
| 536 | @param start range's start (included) | ||
| 537 | @param end range's end (excluded) | ||
| 538 | @returns true if error. | ||
| 539 | */ | ||
| 540 | 156170 | bool Item_func::param_type_is_rejected(uint start, uint end) { | |
| 541 |
2/2✓ Branch 0 taken 156184 times.
✓ Branch 1 taken 24 times.
|
156208 | for (uint i = start; i < end; i++) { |
| 542 |
2/2✓ Branch 0 taken 156143 times.
✓ Branch 1 taken 41 times.
|
156184 | if (i >= arg_count) break; |
| 543 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 38 times.
|
41 | if (args[i]->data_type() == MYSQL_TYPE_INVALID) { |
| 544 | 3 | my_error(ER_INVALID_PARAMETER_USE, MYF(0), "?"); | |
| 545 | 3 | return true; | |
| 546 | } | ||
| 547 | } | ||
| 548 | 156167 | return false; | |
| 549 | } | ||
| 550 | |||
| 551 | /** | ||
| 552 | For arguments of this Item_func ("args" array), all of them: find an | ||
| 553 | argument that is not a dynamic parameter; if found, all dynamic parameters | ||
| 554 | without a valid type get the type of this; if not found, they get type "def". | ||
| 555 | |||
| 556 | @param thd thread handler | ||
| 557 | @param arg_count number of arguments to check | ||
| 558 | @param args array of arguments, size 'arg_count' | ||
| 559 | @param def default type | ||
| 560 | |||
| 561 | @returns false if success, true if error | ||
| 562 | */ | ||
| 563 | 22952160 | inline bool param_type_uses_non_param_inner(THD *thd, uint arg_count, | |
| 564 | Item **args, enum_field_types def) { | ||
| 565 | // Use first non-parameter type as base item | ||
| 566 | // @todo If there are multiple non-parameter items, we could use a | ||
| 567 | // consolidated type instead of the first one (consider CASE, COALESCE, | ||
| 568 | // BETWEEN). | ||
| 569 | 22952160 | uint col_cnt = args[0]->cols(); | |
| 570 |
2/2✓ Branch 0 taken 786 times.
✓ Branch 1 taken 22951363 times.
|
22952149 | if (col_cnt > 1) { |
| 571 | /* | ||
| 572 | Row or subquery object: set parameter type recursively for the ith | ||
| 573 | Item in each argument row. | ||
| 574 | */ | ||
| 575 |
1/2✓ Branch 0 taken 772 times.
✗ Branch 1 not taken.
|
786 | Item **arguments = new (*THR_MALLOC) Item *[arg_count]; |
| 576 |
2/2✓ Branch 0 taken 1802 times.
✓ Branch 1 taken 755 times.
|
2557 | for (uint i = 0; i < col_cnt; i++) { |
| 577 |
2/2✓ Branch 0 taken 4214 times.
✓ Branch 1 taken 1785 times.
|
5999 | for (uint j = 0; j < arg_count; j++) { |
| 578 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 4197 times.
|
4214 | if (args[j]->cols() != col_cnt) // Column count not checked yet |
| 579 | 17 | return false; | |
| 580 |
2/2✓ Branch 0 taken 3140 times.
✓ Branch 1 taken 1057 times.
|
4197 | if (args[j]->type() == Item::ROW_ITEM) |
| 581 | 3140 | arguments[j] = down_cast<Item_row *>(args[j])->element_index(i); | |
| 582 |
1/2✓ Branch 0 taken 1057 times.
✗ Branch 1 not taken.
|
1057 | else if (args[j]->type() == Item::SUBSELECT_ITEM) |
| 583 | 1057 | arguments[j] = (*down_cast<Item_subselect *>(args[j]) | |
| 584 | 1057 | ->unit->get_unit_column_types())[i]; | |
| 585 | } | ||
| 586 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1785 times.
|
1785 | if (param_type_uses_non_param_inner(thd, arg_count, arguments, def)) |
| 587 | ✗ | return true; | |
| 588 | } | ||
| 589 | // Resolving for row done, set data type to MYSQL_TYPE_NULL as final action. | ||
| 590 |
2/2✓ Branch 0 taken 1776 times.
✓ Branch 1 taken 755 times.
|
2531 | for (uint j = 0; j < arg_count; j++) |
| 591 | 1776 | args[j]->set_data_type(MYSQL_TYPE_NULL); | |
| 592 | 755 | return false; | |
| 593 | } | ||
| 594 | 22951363 | Item *base_item = nullptr; | |
| 595 |
2/2✓ Branch 0 taken 22952237 times.
✓ Branch 1 taken 60 times.
|
22952297 | for (uint i = 0; i < arg_count; i++) { |
| 596 |
2/2✓ Branch 0 taken 22951304 times.
✓ Branch 1 taken 934 times.
|
22952237 | if (args[i]->data_type() != MYSQL_TYPE_INVALID) { |
| 597 | 22951304 | base_item = args[i]; | |
| 598 | 22951304 | break; | |
| 599 | } | ||
| 600 | } | ||
| 601 |
2/2✓ Branch 0 taken 120 times.
✓ Branch 1 taken 22951244 times.
|
22951364 | if (base_item == nullptr) { |
| 602 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 120 times.
|
120 | if (args[0]->propagate_type(thd, def)) return true; |
| 603 | 120 | base_item = args[0]; | |
| 604 | } | ||
| 605 |
2/2✓ Branch 0 taken 47292096 times.
✓ Branch 1 taken 22951412 times.
|
70243508 | for (uint i = 0; i < arg_count; i++) { |
| 606 |
2/2✓ Branch 0 taken 47283386 times.
✓ Branch 1 taken 8742 times.
|
47292096 | if (args[i]->data_type() != MYSQL_TYPE_INVALID) continue; |
| 607 |
2/4✓ Branch 0 taken 8758 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8758 times.
|
8742 | if (args[i]->propagate_type(thd, Type_properties(*base_item))) return true; |
| 608 | } | ||
| 609 | 22951412 | return false; | |
| 610 | } | ||
| 611 | |||
| 612 | 27740596 | bool Item_func::param_type_uses_non_param(THD *thd, enum_field_types def) { | |
| 613 |
2/2✓ Branch 0 taken 4790187 times.
✓ Branch 1 taken 22950409 times.
|
27740596 | if (arg_count == 0) return false; |
| 614 | 22950409 | return param_type_uses_non_param_inner(thd, arg_count, args, def); | |
| 615 | } | ||
| 616 | |||
| 617 | 45864002 | bool Item_func::walk(Item_processor processor, enum_walk walk, | |
| 618 | uchar *argument) { | ||
| 619 |
8/8✓ Branch 0 taken 14634293 times.
✓ Branch 1 taken 31231122 times.
✓ Branch 2 taken 10162010 times.
✓ Branch 3 taken 4472283 times.
✓ Branch 4 taken 41 times.
✓ Branch 5 taken 14634010 times.
✓ Branch 6 taken 41 times.
✓ Branch 7 taken 45865132 times.
|
45864002 | if ((walk & enum_walk::PREFIX) && (this->*processor)(argument)) return true; |
| 620 | |||
| 621 | Item **arg, **arg_end; | ||
| 622 |
2/2✓ Branch 0 taken 110456968 times.
✓ Branch 1 taken 45855361 times.
|
156312329 | for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) { |
| 623 |
2/2✓ Branch 0 taken 9947 times.
✓ Branch 1 taken 110447197 times.
|
110456968 | if ((*arg)->walk(processor, walk, argument)) return true; |
| 624 | } | ||
| 625 |
6/6✓ Branch 0 taken 31672601 times.
✓ Branch 1 taken 14183816 times.
✓ Branch 2 taken 27158313 times.
✓ Branch 3 taken 4514288 times.
✓ Branch 4 taken 975 times.
✓ Branch 5 taken 31671400 times.
|
45855361 | return (walk & enum_walk::POSTFIX) && (this->*processor)(argument); |
| 626 | } | ||
| 627 | |||
| 628 | ✗ | void Item_func::traverse_cond(Cond_traverser traverser, void *argument, | |
| 629 | traverse_order order) { | ||
| 630 | ✗ | if (arg_count) { | |
| 631 | Item **arg, **arg_end; | ||
| 632 | |||
| 633 | ✗ | switch (order) { | |
| 634 | ✗ | case (PREFIX): | |
| 635 | ✗ | (*traverser)(this, argument); | |
| 636 | ✗ | for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) { | |
| 637 | ✗ | (*arg)->traverse_cond(traverser, argument, order); | |
| 638 | } | ||
| 639 | ✗ | break; | |
| 640 | ✗ | case (POSTFIX): | |
| 641 | ✗ | for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) { | |
| 642 | ✗ | (*arg)->traverse_cond(traverser, argument, order); | |
| 643 | } | ||
| 644 | ✗ | (*traverser)(this, argument); | |
| 645 | } | ||
| 646 | } else | ||
| 647 | ✗ | (*traverser)(this, argument); | |
| 648 | } | ||
| 649 | |||
| 650 | /** | ||
| 651 | Transform an Item_func object with a transformer callback function. | ||
| 652 | |||
| 653 | The function recursively applies the transform method to each | ||
| 654 | argument of the Item_func node. | ||
| 655 | If the call of the method for an argument item returns a new item | ||
| 656 | the old item is substituted for a new one. | ||
| 657 | After this the transformer is applied to the root node | ||
| 658 | of the Item_func object. | ||
| 659 | */ | ||
| 660 | |||
| 661 | 906391 | Item *Item_func::transform(Item_transformer transformer, uchar *argument) { | |
| 662 |
2/2✓ Branch 0 taken 136384 times.
✓ Branch 1 taken 770007 times.
|
906391 | if (arg_count) { |
| 663 | Item **arg, **arg_end; | ||
| 664 |
2/2✓ Branch 0 taken 272897 times.
✓ Branch 1 taken 136384 times.
|
409281 | for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) { |
| 665 | 272897 | *arg = (*arg)->transform(transformer, argument); | |
| 666 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 272897 times.
|
272897 | if (*arg == nullptr) return nullptr; /* purecov: inspected */ |
| 667 | } | ||
| 668 | } | ||
| 669 |
2/2✓ Branch 0 taken 151882 times.
✓ Branch 1 taken 754509 times.
|
906391 | return (this->*transformer)(argument); |
| 670 | } | ||
| 671 | |||
| 672 | /** | ||
| 673 | Compile Item_func object with a processor and a transformer | ||
| 674 | callback functions. | ||
| 675 | |||
| 676 | First the function applies the analyzer to the root node of | ||
| 677 | the Item_func object. Then if the analyzer succeeeds (returns true) | ||
| 678 | the function recursively applies the compile method to each argument | ||
| 679 | of the Item_func node. | ||
| 680 | If the call of the method for an argument item returns a new item | ||
| 681 | the old item is substituted for a new one. | ||
| 682 | After this the transformer is applied to the root node | ||
| 683 | of the Item_func object. | ||
| 684 | */ | ||
| 685 | |||
| 686 | 9600900 | Item *Item_func::compile(Item_analyzer analyzer, uchar **arg_p, | |
| 687 | Item_transformer transformer, uchar *arg_t) { | ||
| 688 |
4/4✓ Branch 0 taken 6599805 times.
✓ Branch 1 taken 3001095 times.
✓ Branch 2 taken 55658 times.
✓ Branch 3 taken 9545324 times.
|
9600900 | if (!(this->*analyzer)(arg_p)) return this; |
| 689 |
2/2✓ Branch 0 taken 9228018 times.
✓ Branch 1 taken 317306 times.
|
9545324 | if (arg_count) { |
| 690 | Item **arg, **arg_end; | ||
| 691 |
2/2✓ Branch 0 taken 19581705 times.
✓ Branch 1 taken 9228114 times.
|
28809819 | for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) { |
| 692 | /* | ||
| 693 | The same parameter value of arg_p must be passed | ||
| 694 | to analyze any argument of the condition formula. | ||
| 695 | */ | ||
| 696 | 19581705 | uchar *arg_v = *arg_p; | |
| 697 |
1/2✓ Branch 0 taken 19581751 times.
✗ Branch 1 not taken.
|
19581705 | Item *new_item = (*arg)->compile(analyzer, &arg_v, transformer, arg_t); |
| 698 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 19581749 times.
|
19581751 | if (new_item == nullptr) return nullptr; |
| 699 |
4/6✓ Branch 0 taken 94854 times.
✓ Branch 1 taken 19486895 times.
✓ Branch 2 taken 94854 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 94906 times.
✗ Branch 5 not taken.
|
19581749 | if (*arg != new_item) current_thd->change_item_tree(arg, new_item); |
| 700 | } | ||
| 701 | } | ||
| 702 |
2/2✓ Branch 0 taken 6065391 times.
✓ Branch 1 taken 3480029 times.
|
9545420 | return (this->*transformer)(arg_t); |
| 703 | } | ||
| 704 | |||
| 705 | /** | ||
| 706 | See comments in Item_cmp_func::split_sum_func() | ||
| 707 | */ | ||
| 708 | |||
| 709 | 401002 | void Item_func::split_sum_func(THD *thd, Ref_item_array ref_item_array, | |
| 710 | mem_root_deque<Item *> *fields) { | ||
| 711 | Item **arg, **arg_end; | ||
| 712 |
2/2✓ Branch 0 taken 756946 times.
✓ Branch 1 taken 401002 times.
|
1157948 | for (arg = args, arg_end = args + arg_count; arg != arg_end; arg++) |
| 713 | 756946 | (*arg)->split_sum_func2(thd, ref_item_array, fields, arg, true); | |
| 714 | 401002 | } | |
| 715 | |||
| 716 | 55214882 | void Item_func::update_used_tables() { | |
| 717 | 55214882 | used_tables_cache = get_initial_pseudo_tables(); | |
| 718 | 55215254 | not_null_tables_cache = 0; | |
| 719 | |||
| 720 |
2/2✓ Branch 0 taken 114228656 times.
✓ Branch 1 taken 55215035 times.
|
169443691 | for (uint i = 0; i < arg_count; i++) { |
| 721 | 114228656 | args[i]->update_used_tables(); | |
| 722 | 114228412 | used_tables_cache |= args[i]->used_tables(); | |
| 723 |
2/2✓ Branch 0 taken 107790057 times.
✓ Branch 1 taken 6438257 times.
|
114228314 | if (null_on_null) not_null_tables_cache |= args[i]->not_null_tables(); |
| 724 | 114227907 | add_accum_properties(args[i]); | |
| 725 | } | ||
| 726 | 55215035 | } | |
| 727 | |||
| 728 | 1443092 | void Item_func::print(const THD *thd, String *str, | |
| 729 | enum_query_type query_type) const { | ||
| 730 |
1/2✓ Branch 0 taken 1443092 times.
✗ Branch 1 not taken.
|
1443092 | str->append(func_name()); |
| 731 | 1443092 | str->append('('); | |
| 732 | 1443092 | print_args(thd, str, 0, query_type); | |
| 733 | 1443092 | str->append(')'); | |
| 734 | 1443092 | } | |
| 735 | |||
| 736 | 1495452 | void Item_func::print_args(const THD *thd, String *str, uint from, | |
| 737 | enum_query_type query_type) const { | ||
| 738 |
2/2✓ Branch 0 taken 3240063 times.
✓ Branch 1 taken 1495452 times.
|
4735515 | for (uint i = from; i < arg_count; i++) { |
| 739 |
2/2✓ Branch 0 taken 1834055 times.
✓ Branch 1 taken 1406008 times.
|
3240063 | if (i != from) str->append(','); |
| 740 | 3240063 | args[i]->print(thd, str, query_type); | |
| 741 | } | ||
| 742 | 1495452 | } | |
| 743 | |||
| 744 | 1012711 | void Item_func::print_op(const THD *thd, String *str, | |
| 745 | enum_query_type query_type) const { | ||
| 746 | 1012711 | str->append('('); | |
| 747 |
2/2✓ Branch 0 taken 1012711 times.
✓ Branch 1 taken 1012711 times.
|
2025422 | for (uint i = 0; i < arg_count - 1; i++) { |
| 748 | 1012711 | args[i]->print(thd, str, query_type); | |
| 749 | 1012711 | str->append(' '); | |
| 750 |
1/2✓ Branch 0 taken 1012711 times.
✗ Branch 1 not taken.
|
1012711 | str->append(func_name()); |
| 751 | 1012711 | str->append(' '); | |
| 752 | } | ||
| 753 | 1012711 | args[arg_count - 1]->print(thd, str, query_type); | |
| 754 | 1012711 | str->append(')'); | |
| 755 | 1012711 | } | |
| 756 | |||
| 757 | /// @note Please keep in sync with Item_sum::eq(). | ||
| 758 | 409500 | bool Item_func::eq(const Item *item, bool binary_cmp) const { | |
| 759 | /* Assume we don't have rtti */ | ||
| 760 |
2/2✓ Branch 0 taken 70110 times.
✓ Branch 1 taken 339390 times.
|
409500 | if (this == item) return true; |
| 761 |
2/2✓ Branch 0 taken 134554 times.
✓ Branch 1 taken 204836 times.
|
339390 | if (item->type() != FUNC_ITEM) return false; |
| 762 | 204836 | const Item_func *item_func = down_cast<const Item_func *>(item); | |
| 763 | Item_func::Functype func_type; | ||
| 764 | 204836 | if ((func_type = functype()) != item_func->functype() || | |
| 765 |
4/4✓ Branch 0 taken 121057 times.
✓ Branch 1 taken 336 times.
✓ Branch 2 taken 120711 times.
✓ Branch 3 taken 346 times.
|
121393 | arg_count != item_func->arg_count || |
| 766 | 120711 | (func_type != Item_func::FUNC_SP && | |
| 767 |
8/8✓ Branch 0 taken 121393 times.
✓ Branch 1 taken 83443 times.
✓ Branch 2 taken 118067 times.
✓ Branch 3 taken 2644 times.
✓ Branch 4 taken 346 times.
✓ Branch 5 taken 118067 times.
✓ Branch 6 taken 86599 times.
✓ Branch 7 taken 118237 times.
|
326575 | strcmp(func_name(), item_func->func_name()) != 0) || |
| 768 | 346 | (func_type == Item_func::FUNC_SP && | |
| 769 |
2/2✓ Branch 0 taken 176 times.
✓ Branch 1 taken 170 times.
|
346 | my_strcasecmp(system_charset_info, func_name(), item_func->func_name()))) |
| 770 | 86599 | return false; | |
| 771 | 118237 | return AllItemsAreEqual(args, item_func->args, arg_count, binary_cmp); | |
| 772 | } | ||
| 773 | |||
| 774 | 55353 | Field *Item_func::tmp_table_field(TABLE *table) { | |
| 775 | 55353 | Field *field = nullptr; | |
| 776 | |||
| 777 |
3/5✓ Branch 0 taken 5836 times.
✓ Branch 1 taken 127 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 49390 times.
✗ Branch 4 not taken.
|
55353 | switch (result_type()) { |
| 778 | 5836 | case INT_RESULT: | |
| 779 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5835 times.
|
5836 | if (this->data_type() == MYSQL_TYPE_YEAR) |
| 780 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | field = new (*THR_MALLOC) Field_year(is_nullable(), item_name.ptr()); |
| 781 |
2/2✓ Branch 0 taken 2171 times.
✓ Branch 1 taken 3664 times.
|
5835 | else if (max_length > MY_INT32_NUM_DECIMAL_DIGITS) |
| 782 |
1/2✓ Branch 0 taken 2171 times.
✗ Branch 1 not taken.
|
6513 | field = new (*THR_MALLOC) Field_longlong( |
| 783 |
1/2✓ Branch 0 taken 2171 times.
✗ Branch 1 not taken.
|
6513 | max_length, is_nullable(), item_name.ptr(), unsigned_flag); |
| 784 | else | ||
| 785 |
1/2✓ Branch 0 taken 3664 times.
✗ Branch 1 not taken.
|
14656 | field = new (*THR_MALLOC) Field_long(max_length, is_nullable(), |
| 786 |
1/2✓ Branch 0 taken 3664 times.
✗ Branch 1 not taken.
|
10992 | item_name.ptr(), unsigned_flag); |
| 787 | 5836 | break; | |
| 788 | 127 | case REAL_RESULT: | |
| 789 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 124 times.
|
127 | if (this->data_type() == MYSQL_TYPE_FLOAT) { |
| 790 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
9 | field = new (*THR_MALLOC) |
| 791 | 3 | Field_float(max_char_length(), is_nullable(), item_name.ptr(), | |
| 792 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
6 | decimals, unsigned_flag); |
| 793 | } else { | ||
| 794 |
1/2✓ Branch 0 taken 124 times.
✗ Branch 1 not taken.
|
372 | field = new (*THR_MALLOC) |
| 795 | 124 | Field_double(max_char_length(), is_nullable(), item_name.ptr(), | |
| 796 |
1/2✓ Branch 0 taken 124 times.
✗ Branch 1 not taken.
|
248 | decimals, unsigned_flag); |
| 797 | } | ||
| 798 | 127 | break; | |
| 799 | ✗ | case STRING_RESULT: | |
| 800 | ✗ | return make_string_field(table); | |
| 801 | break; | ||
| 802 | 49390 | case DECIMAL_RESULT: | |
| 803 | 49390 | field = Field_new_decimal::create_from_item(this); | |
| 804 | 49390 | break; | |
| 805 | ✗ | case ROW_RESULT: | |
| 806 | default: | ||
| 807 | // This case should never be chosen | ||
| 808 | ✗ | assert(0); | |
| 809 | field = nullptr; | ||
| 810 | break; | ||
| 811 | } | ||
| 812 |
1/2✓ Branch 0 taken 55353 times.
✗ Branch 1 not taken.
|
55353 | if (field) field->init(table); |
| 813 | 55353 | return field; | |
| 814 | } | ||
| 815 | |||
| 816 | 1306390 | my_decimal *Item_func::val_decimal(my_decimal *decimal_value) { | |
| 817 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1306390 times.
|
1306390 | assert(fixed); |
| 818 | 1306390 | longlong nr = val_int(); | |
| 819 |
2/2✓ Branch 0 taken 572066 times.
✓ Branch 1 taken 734324 times.
|
1306390 | if (null_value) return nullptr; /* purecov: inspected */ |
| 820 | 734324 | int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value); | |
| 821 | 734324 | return decimal_value; | |
| 822 | } | ||
| 823 | |||
| 824 | 518286 | String *Item_real_func::val_str(String *str) { | |
| 825 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 518286 times.
|
518286 | assert(fixed == 1); |
| 826 | 518286 | double nr = val_real(); | |
| 827 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 518176 times.
|
518185 | if (null_value) return nullptr; /* purecov: inspected */ |
| 828 | 518176 | str->set_real(nr, decimals, collation.collation); | |
| 829 | 520741 | return str; | |
| 830 | } | ||
| 831 | |||
| 832 | 12 | my_decimal *Item_real_func::val_decimal(my_decimal *decimal_value) { | |
| 833 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | assert(fixed); |
| 834 | 12 | double nr = val_real(); | |
| 835 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 5 times.
|
12 | if (null_value) return nullptr; /* purecov: inspected */ |
| 836 | 5 | double2my_decimal(E_DEC_FATAL_ERROR, nr, decimal_value); | |
| 837 | 5 | return decimal_value; | |
| 838 | } | ||
| 839 | |||
| 840 | 96 | void Item_func::fix_num_length_and_dec() { | |
| 841 | 96 | uint fl_length = 0; | |
| 842 | 96 | decimals = 0; | |
| 843 |
2/2✓ Branch 0 taken 112 times.
✓ Branch 1 taken 96 times.
|
208 | for (uint i = 0; i < arg_count; i++) { |
| 844 | 112 | decimals = max(decimals, args[i]->decimals); | |
| 845 | 112 | fl_length = max(fl_length, args[i]->max_length); | |
| 846 | } | ||
| 847 | 96 | max_length = float_length(decimals); | |
| 848 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 94 times.
|
96 | if (fl_length > max_length) { |
| 849 | 2 | decimals = DECIMAL_NOT_SPECIFIED; | |
| 850 | 2 | max_length = float_length(DECIMAL_NOT_SPECIFIED); | |
| 851 | } | ||
| 852 | 96 | } | |
| 853 | |||
| 854 | 2619937 | void Item_func_numhybrid::fix_num_length_and_dec() {} | |
| 855 | |||
| 856 | 15189 | void Item_func::signal_divide_by_null() { | |
| 857 | 15189 | THD *thd = current_thd; | |
| 858 |
2/2✓ Branch 0 taken 10996 times.
✓ Branch 1 taken 4193 times.
|
15189 | if (thd->variables.sql_mode & MODE_ERROR_FOR_DIVISION_BY_ZERO) |
| 859 | 10996 | push_warning(thd, Sql_condition::SL_WARNING, ER_DIVISION_BY_ZERO, | |
| 860 | ER_THD(thd, ER_DIVISION_BY_ZERO)); | ||
| 861 | 15189 | null_value = true; | |
| 862 | 15189 | } | |
| 863 | |||
| 864 | 60 | void Item_func::signal_invalid_argument_for_log() { | |
| 865 | 60 | THD *thd = current_thd; | |
| 866 | 60 | push_warning(thd, Sql_condition::SL_WARNING, | |
| 867 | ER_INVALID_ARGUMENT_FOR_LOGARITHM, | ||
| 868 | ER_THD(thd, ER_INVALID_ARGUMENT_FOR_LOGARITHM)); | ||
| 869 | 60 | null_value = true; | |
| 870 | 60 | } | |
| 871 | |||
| 872 | 56196 | Item *Item_func::get_tmp_table_item(THD *thd) { | |
| 873 |
1/2✓ Branch 0 taken 56196 times.
✗ Branch 1 not taken.
|
56196 | DBUG_TRACE; |
| 874 | |||
| 875 | /* | ||
| 876 | For items with aggregate functions, return the copy | ||
| 877 | of the function. | ||
| 878 | For constant items, return the same object, as fields | ||
| 879 | are not created in temp tables for them. | ||
| 880 | For items with windowing functions, return the same | ||
| 881 | object (temp table fields are not created for windowing | ||
| 882 | functions if they are not evaluated at this stage). | ||
| 883 | */ | ||
| 884 |
6/6✓ Branch 0 taken 55852 times.
✓ Branch 1 taken 344 times.
✓ Branch 2 taken 55750 times.
✓ Branch 3 taken 102 times.
✓ Branch 4 taken 54280 times.
✓ Branch 5 taken 1916 times.
|
111946 | if (!has_aggregation() && !has_wf() && |
| 885 |
3/4✓ Branch 0 taken 55750 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1470 times.
✓ Branch 3 taken 54280 times.
|
55750 | !(const_for_execution() && |
| 886 |
2/4✓ Branch 0 taken 1470 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1470 times.
|
1470 | evaluate_during_optimization(this, thd->lex->current_query_block()))) { |
| 887 |
2/4✓ Branch 0 taken 54280 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 54280 times.
✗ Branch 3 not taken.
|
54280 | Item *result = new Item_field(result_field); |
| 888 | 54280 | return result; | |
| 889 | } | ||
| 890 |
1/2✓ Branch 0 taken 1916 times.
✗ Branch 1 not taken.
|
1916 | Item *result = copy_or_same(thd); |
| 891 | 1916 | return result; | |
| 892 | 56196 | } | |
| 893 | |||
| 894 | 62968560 | const Item_field *Item_func::contributes_to_filter( | |
| 895 | table_map read_tables, table_map filter_for_table, | ||
| 896 | const MY_BITMAP *fields_to_ignore) const { | ||
| 897 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62968560 times.
|
62968560 | assert((read_tables & filter_for_table) == 0); |
| 898 | /* | ||
| 899 | Multiple equality (Item_equal) should not call this function | ||
| 900 | because it would reject valid comparisons. | ||
| 901 | */ | ||
| 902 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62968786 times.
|
62968560 | assert(functype() != MULT_EQUAL_FUNC); |
| 903 | |||
| 904 | /* | ||
| 905 | To contribute to filtering effect, the condition must refer to | ||
| 906 | exactly one unread table: the table filtering is currently | ||
| 907 | calculated for. | ||
| 908 | */ | ||
| 909 |
2/2✓ Branch 0 taken 53894945 times.
✓ Branch 1 taken 9073829 times.
|
62968786 | if ((used_tables() & ~read_tables) != filter_for_table) return nullptr; |
| 910 | |||
| 911 | /* | ||
| 912 | Whether or not this Item_func has an operand that is a field in | ||
| 913 | 'filter_for_table' that is not in 'fields_to_ignore'. | ||
| 914 | */ | ||
| 915 | 9073829 | Item_field *usable_field = nullptr; | |
| 916 | |||
| 917 | /* | ||
| 918 | Whether or not this Item_func has an operand that can be used as | ||
| 919 | available value. arg_count==1 for Items with implicit values like | ||
| 920 | "field IS NULL". | ||
| 921 | */ | ||
| 922 | 9073829 | bool found_comparable = (arg_count == 1); | |
| 923 | |||
| 924 |
2/2✓ Branch 0 taken 18104932 times.
✓ Branch 1 taken 9073660 times.
|
27178592 | for (uint i = 0; i < arg_count; i++) { |
| 925 | 18104932 | const Item::Type arg_type = args[i]->real_item()->type(); | |
| 926 | |||
| 927 |
2/2✓ Branch 0 taken 734 times.
✓ Branch 1 taken 18104250 times.
|
18104984 | if (arg_type == Item::SUBSELECT_ITEM) { |
| 928 |
2/2✓ Branch 0 taken 490 times.
✓ Branch 1 taken 244 times.
|
734 | if (args[i]->const_for_execution()) { |
| 929 | // Constant subquery, i.e., not a dependent subquery. | ||
| 930 | 490 | found_comparable = true; | |
| 931 | 490 | continue; | |
| 932 | } | ||
| 933 | |||
| 934 | /* | ||
| 935 | This is either "fld OP <dependent_subquery>" or "fld BETWEEN X | ||
| 936 | and Y" where either X or Y is a dependent subquery. Filtering | ||
| 937 | effect should not be calculated for this item because the cost | ||
| 938 | of evaluating the dependent subquery is currently not | ||
| 939 | calculated and its accompanying filtering effect is too | ||
| 940 | uncertain. See WL#7384. | ||
| 941 | */ | ||
| 942 | 244 | return nullptr; | |
| 943 | } // ... if subquery. | ||
| 944 | |||
| 945 | 18104250 | const table_map used_tabs = args[i]->used_tables(); | |
| 946 | |||
| 947 |
4/4✓ Branch 0 taken 3720074 times.
✓ Branch 1 taken 14384199 times.
✓ Branch 2 taken 3671406 times.
✓ Branch 3 taken 48668 times.
|
18104273 | if (arg_type == Item::FIELD_ITEM && (used_tabs == filter_for_table)) { |
| 948 | /* | ||
| 949 | The qualifying table of args[i] is filter_for_table. args[i] | ||
| 950 | may be a field or a reference to a field, e.g. through a | ||
| 951 | view. | ||
| 952 | */ | ||
| 953 | 3671406 | Item_field *fld = static_cast<Item_field *>(args[i]->real_item()); | |
| 954 | |||
| 955 | /* | ||
| 956 | Use args[i] as value if | ||
| 957 | 1) this field shall be ignored, or | ||
| 958 | 2) a usable field has already been found (meaning that | ||
| 959 | this is "filter_for_table.colX OP filter_for_table.colY"). | ||
| 960 | */ | ||
| 961 |
6/6✓ Branch 0 taken 3634850 times.
✓ Branch 1 taken 36556 times.
✓ Branch 2 taken 1149 times.
✓ Branch 3 taken 3633701 times.
✓ Branch 4 taken 37705 times.
✓ Branch 5 taken 3633701 times.
|
3671406 | if (bitmap_is_set(fields_to_ignore, fld->field->field_index()) || // 1) |
| 962 | usable_field) // 2) | ||
| 963 | { | ||
| 964 | 37705 | found_comparable = true; | |
| 965 | 37705 | continue; | |
| 966 | } | ||
| 967 | |||
| 968 | /* | ||
| 969 | This field shall contribute to filtering effect if a | ||
| 970 | value is found for it | ||
| 971 | */ | ||
| 972 | 3633701 | usable_field = fld; | |
| 973 | 3633701 | } // if field. | |
| 974 | else { | ||
| 975 | /* | ||
| 976 | It's not a subquery. May be a function, a constant, an outer | ||
| 977 | reference, a field of another table... | ||
| 978 | |||
| 979 | Already checked that this predicate does not refer to tables | ||
| 980 | later in the join sequence. Verify it: | ||
| 981 | */ | ||
| 982 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14432867 times.
|
14432867 | assert(!(used_tabs & (~read_tables & ~filter_for_table))); |
| 983 | 14432867 | found_comparable = true; | |
| 984 | } | ||
| 985 | } | ||
| 986 |
1/2✓ Branch 0 taken 9073664 times.
✗ Branch 1 not taken.
|
9073660 | return (found_comparable ? usable_field : nullptr); |
| 987 | } | ||
| 988 | |||
| 989 | 134186 | bool Item_func::is_valid_for_pushdown(uchar *arg) { | |
| 990 | Condition_pushdown::Derived_table_info *dti = | ||
| 991 | 134186 | pointer_cast<Condition_pushdown::Derived_table_info *>(arg); | |
| 992 | // We cannot push conditions that are not deterministic to a | ||
| 993 | // derived table having set operations. | ||
| 994 |
4/4✓ Branch 0 taken 200 times.
✓ Branch 1 taken 133986 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 194 times.
|
134186 | return (dti->is_set_operation() && is_non_deterministic()); |
| 995 | } | ||
| 996 | |||
| 997 | 43 | bool Item_func::check_column_in_window_functions(uchar *arg [[maybe_unused]]) { | |
| 998 | // Pushing conditions having non-deterministic results must be done with | ||
| 999 | // care, or it may result in eliminating rows which would have | ||
| 1000 | // otherwise contributed to aggregations. | ||
| 1001 | // For Ex: SELECT * FROM (SELECT a AS x, SUM(b) FROM t1 GROUP BY a) dt | ||
| 1002 | // WHERE x>5*RAND() AND x<3. | ||
| 1003 | // In this case, x<3 is pushed to the WHERE clause of the derived table | ||
| 1004 | // because there is grouping on "a". If we did the same for the random | ||
| 1005 | // condition, this condition might reduce the number of rows that get | ||
| 1006 | // qualified for grouping, resulting in wrong values for SUM. Similarly for | ||
| 1007 | // window functions. So we refrain from pushing the random condition | ||
| 1008 | // past the last operation done in the derived table's | ||
| 1009 | // materialization. Therefore, if there are window functions we cannot push | ||
| 1010 | // to HAVING, and if there is GROUP BY we cannot push to WHERE. | ||
| 1011 | // See also Item_field::is_valid_for_pushdown(). | ||
| 1012 | 43 | return is_non_deterministic(); | |
| 1013 | } | ||
| 1014 | |||
| 1015 | 78 | bool Item_func::check_column_in_group_by(uchar *arg [[maybe_unused]]) { | |
| 1016 | 78 | return is_non_deterministic(); | |
| 1017 | } | ||
| 1018 | |||
| 1019 | 6401397 | bool is_function_of_type(const Item *item, Item_func::Functype type) { | |
| 1020 |
2/2✓ Branch 0 taken 45713 times.
✓ Branch 1 taken 6355684 times.
|
6447110 | return item->type() == Item::FUNC_ITEM && |
| 1021 |
2/2✓ Branch 0 taken 4446 times.
✓ Branch 1 taken 41267 times.
|
6447110 | down_cast<const Item_func *>(item)->functype() == type; |
| 1022 | } | ||
| 1023 | |||
| 1024 | 105 | bool contains_function_of_type(Item *item, Item_func::Functype type) { | |
| 1025 |
1/2✓ Branch 0 taken 105 times.
✗ Branch 1 not taken.
|
210 | return WalkItem(item, enum_walk::PREFIX, [type](Item *inner_item) { |
| 1026 | 217 | return is_function_of_type(inner_item, type); | |
| 1027 | 210 | }); | |
| 1028 | } | ||
| 1029 | |||
| 1030 | /** | ||
| 1031 | Return new Item_field if given expression matches GC | ||
| 1032 | |||
| 1033 | @see substitute_gc() | ||
| 1034 | |||
| 1035 | @param func Expression to be replaced | ||
| 1036 | @param fld GCs field | ||
| 1037 | @param type Result type to match with Field | ||
| 1038 | @param[out] found If given, just return found field, without Item_field | ||
| 1039 | |||
| 1040 | @returns | ||
| 1041 | item new Item_field for matched GC | ||
| 1042 | NULL otherwise | ||
| 1043 | */ | ||
| 1044 | |||
| 1045 | 1194 | Item_field *get_gc_for_expr(const Item *func, Field *fld, Item_result type, | |
| 1046 | Field **found) { | ||
| 1047 | 1194 | func = func->real_item(); | |
| 1048 | 1194 | Item *expr = fld->gcol_info->expr_item; | |
| 1049 | |||
| 1050 | /* | ||
| 1051 | In the case where the generated column expression returns JSON and | ||
| 1052 | the predicate compares the values as strings, it is not safe to | ||
| 1053 | replace the expression with the generated column, since the | ||
| 1054 | indexed string values will be double-quoted. The generated column | ||
| 1055 | expression should use the JSON_UNQUOTE function to strip off the | ||
| 1056 | double-quotes in order to get a usable index for looking up | ||
| 1057 | strings. See also the comment below. | ||
| 1058 | */ | ||
| 1059 |
6/6✓ Branch 0 taken 839 times.
✓ Branch 1 taken 355 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 837 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 1192 times.
|
1194 | if (type == STRING_RESULT && expr->data_type() == MYSQL_TYPE_JSON) |
| 1060 | 2 | return nullptr; | |
| 1061 | |||
| 1062 | /* | ||
| 1063 | In order to match expressions against a functional index's expression, | ||
| 1064 | it's needed to skip CAST(.. AS .. ) and potentially COLLATE from the latter. | ||
| 1065 | This can't be joined with striping json_unquote below, since we might need | ||
| 1066 | to skip it too in expression like: | ||
| 1067 | CAST(JSON_UNQUOTE(<expr>) AS CHAR(X)) | ||
| 1068 | |||
| 1069 | Also skip unquoting function. This is needed to address JSON string | ||
| 1070 | comparison issue. All JSON_* functions return quoted strings. In | ||
| 1071 | order to create usable index, GC column expression has to include | ||
| 1072 | JSON_UNQUOTE function, e.g JSON_UNQUOTE(JSON_EXTRACT(..)). | ||
| 1073 | Hence, the unquoting function in column expression have to be | ||
| 1074 | skipped in order to correctly match GC expr to expr in | ||
| 1075 | WHERE condition. The exception is if user has explicitly used | ||
| 1076 | JSON_UNQUOTE in WHERE condition. | ||
| 1077 | */ | ||
| 1078 | |||
| 1079 | 4768 | for (Item_func::Functype functype : | |
| 1080 | {Item_func::COLLATE_FUNC, Item_func::TYPECAST_FUNC, | ||
| 1081 |
2/2✓ Branch 0 taken 3576 times.
✓ Branch 1 taken 1192 times.
|
5960 | Item_func::JSON_UNQUOTE_FUNC}) { |
| 1082 |
5/6✓ Branch 0 taken 3576 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1141 times.
✓ Branch 3 taken 2435 times.
✓ Branch 4 taken 1050 times.
✓ Branch 5 taken 2526 times.
|
4717 | if (is_function_of_type(expr, functype) && |
| 1083 |
3/4✓ Branch 0 taken 1141 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1050 times.
✓ Branch 3 taken 91 times.
|
1141 | !is_function_of_type(func, functype)) { |
| 1084 |
1/2✓ Branch 0 taken 1050 times.
✗ Branch 1 not taken.
|
1050 | expr = down_cast<Item_func *>(expr)->get_arg(0); |
| 1085 | } | ||
| 1086 | } | ||
| 1087 | |||
| 1088 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1191 times.
|
1192 | if (!expr->can_be_substituted_for_gc(fld->is_array())) { |
| 1089 | 1 | return nullptr; | |
| 1090 | } | ||
| 1091 | |||
| 1092 | // JSON implementation always uses binary collation | ||
| 1093 | 1191 | bool bin_cmp = (expr->data_type() == MYSQL_TYPE_JSON); | |
| 1094 |
6/6✓ Branch 0 taken 1074 times.
✓ Branch 1 taken 117 times.
✓ Branch 2 taken 883 times.
✓ Branch 3 taken 191 times.
✓ Branch 4 taken 883 times.
✓ Branch 5 taken 308 times.
|
1191 | if (type == fld->result_type() && func->eq(expr, bin_cmp)) { |
| 1095 |
2/2✓ Branch 0 taken 238 times.
✓ Branch 1 taken 645 times.
|
883 | if (found) { |
| 1096 | // Temporary mark the field in order to check correct value conversion | ||
| 1097 | 238 | fld->table->mark_column_used(fld, MARK_COLUMNS_TEMP); | |
| 1098 | 238 | *found = fld; | |
| 1099 | 238 | return nullptr; | |
| 1100 | } | ||
| 1101 | // Mark field for read | ||
| 1102 | 645 | fld->table->mark_column_used(fld, MARK_COLUMNS_READ); | |
| 1103 |
2/4✓ Branch 0 taken 645 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 645 times.
✗ Branch 3 not taken.
|
645 | Item_field *field = new Item_field(fld); |
| 1104 | 645 | return field; | |
| 1105 | } | ||
| 1106 |
2/2✓ Branch 0 taken 49 times.
✓ Branch 1 taken 259 times.
|
308 | if (found) *found = nullptr; |
| 1107 | 308 | return nullptr; | |
| 1108 | } | ||
| 1109 | |||
| 1110 | /** | ||
| 1111 | Attempt to substitute an expression with an equivalent generated | ||
| 1112 | column in a predicate. | ||
| 1113 | |||
| 1114 | @param expr the expression that should be substituted | ||
| 1115 | @param value if given, value will be coerced to GC field's type and | ||
| 1116 | the result will substitute the original value. Used by | ||
| 1117 | multi-valued index. | ||
| 1118 | @param gc_fields list of indexed generated columns to check for | ||
| 1119 | equivalence with the expression | ||
| 1120 | @param type the acceptable type of the generated column that | ||
| 1121 | replaces the expression | ||
| 1122 | @param predicate the predicate in which the substitution is done | ||
| 1123 | |||
| 1124 | @return true on error, false on success | ||
| 1125 | */ | ||
| 1126 | 797 | static bool substitute_gc_expression(Item **expr, Item **value, | |
| 1127 | List<Field> *gc_fields, Item_result type, | ||
| 1128 | Item_func *predicate) { | ||
| 1129 |
1/2✓ Branch 0 taken 797 times.
✗ Branch 1 not taken.
|
797 | List_iterator<Field> li(*gc_fields); |
| 1130 | 797 | Item_field *item_field = nullptr; | |
| 1131 |
2/2✓ Branch 0 taken 917 times.
✓ Branch 1 taken 153 times.
|
1070 | while (Field *field = li++) { |
| 1132 | // Check whether the field has usable keys. | ||
| 1133 | 917 | Key_map tkm = field->part_of_key; | |
| 1134 | 917 | tkm.merge(field->part_of_prefixkey); // Include prefix keys. | |
| 1135 | 917 | tkm.intersect(field->table->keys_in_use_for_query); | |
| 1136 | /* | ||
| 1137 | Don't substitute if: | ||
| 1138 | 1) Key is disabled | ||
| 1139 | 2) It's a multi-valued index's field and predicate isn't MEMBER OF | ||
| 1140 | */ | ||
| 1141 |
4/4✓ Branch 0 taken 903 times.
✓ Branch 1 taken 14 times.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 899 times.
|
1820 | if (tkm.is_clear_all() || // (1) |
| 1142 |
6/8✓ Branch 0 taken 903 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 552 times.
✓ Branch 3 taken 351 times.
✓ Branch 4 taken 552 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✓ Branch 7 taken 548 times.
|
903 | (field->is_array() && predicate->functype() != // (2) |
| 1143 | Item_func::MEMBER_OF_FUNC)) | ||
| 1144 | 18 | continue; | |
| 1145 | // If the field is a hidden field used by a functional index, we require | ||
| 1146 | // that the collation of the field must match the collation of the | ||
| 1147 | // expression. If not, we might end up with the wrong result when using | ||
| 1148 | // the index (see bug#27337092). Ideally, this should be done for normal | ||
| 1149 | // generated columns as well, but that is delayed to a later fix since the | ||
| 1150 | // impact might be quite large. | ||
| 1151 |
4/4✓ Branch 0 taken 617 times.
✓ Branch 1 taken 282 times.
✓ Branch 2 taken 894 times.
✓ Branch 3 taken 5 times.
|
1516 | if (!(field->is_field_for_functional_index() && |
| 1152 |
3/4✓ Branch 0 taken 617 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 599 times.
|
617 | field->match_collation_to_optimize_range() && |
| 1153 |
3/4✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 5 times.
|
18 | (*expr)->collation.collation != field->charset())) { |
| 1154 |
1/2✓ Branch 0 taken 894 times.
✗ Branch 1 not taken.
|
894 | item_field = get_gc_for_expr(*expr, field, type); |
| 1155 |
2/2✓ Branch 0 taken 644 times.
✓ Branch 1 taken 250 times.
|
894 | if (item_field != nullptr) break; |
| 1156 | } | ||
| 1157 | 273 | } | |
| 1158 | |||
| 1159 |
2/2✓ Branch 0 taken 153 times.
✓ Branch 1 taken 644 times.
|
797 | if (item_field == nullptr) return false; |
| 1160 | |||
| 1161 | // A matching expression is found. Substitute the expression with | ||
| 1162 | // the matching generated column. | ||
| 1163 |
1/2✓ Branch 0 taken 644 times.
✗ Branch 1 not taken.
|
644 | THD *thd = current_thd; |
| 1164 |
6/8✓ Branch 0 taken 644 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 464 times.
✓ Branch 3 taken 180 times.
✓ Branch 4 taken 464 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 464 times.
✓ Branch 7 taken 180 times.
|
644 | if (item_field->returns_array() && value) { |
| 1165 | 464 | Json_wrapper wr; | |
| 1166 | 464 | String str_val, buf; | |
| 1167 | 464 | Field_typed_array *afld = down_cast<Field_typed_array *>(item_field->field); | |
| 1168 | |||
| 1169 |
1/2✓ Branch 0 taken 464 times.
✗ Branch 1 not taken.
|
464 | Functional_index_error_handler functional_index_error_handler(afld, thd); |
| 1170 | |||
| 1171 |
2/4✓ Branch 0 taken 464 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 464 times.
|
464 | if (get_json_atom_wrapper(value, 0, "MEMBER OF", &str_val, &buf, &wr, |
| 1172 | nullptr, true)) | ||
| 1173 | ✗ | return true; | |
| 1174 | |||
| 1175 | 464 | auto to_wr = make_unique_destroy_only<Json_wrapper>(thd->mem_root); | |
| 1176 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 464 times.
|
464 | if (to_wr == nullptr) return true; |
| 1177 | |||
| 1178 | // Don't substitute if value can't be coerced to field's type | ||
| 1179 |
3/4✓ Branch 0 taken 464 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 462 times.
|
464 | if (afld->coerce_json_value(&wr, /*no_error=*/true, to_wr.get())) |
| 1180 | 2 | return false; | |
| 1181 | |||
| 1182 | Item_json *jsn = | ||
| 1183 |
2/4✓ Branch 0 taken 462 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 462 times.
✗ Branch 3 not taken.
|
462 | new (thd->mem_root) Item_json(std::move(to_wr), predicate->item_name); |
| 1184 |
4/8✓ Branch 0 taken 462 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 462 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 462 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 462 times.
|
462 | if (jsn == nullptr || jsn->fix_fields(thd, nullptr)) return true; |
| 1185 |
1/2✓ Branch 0 taken 462 times.
✗ Branch 1 not taken.
|
462 | thd->change_item_tree(value, jsn); |
| 1186 |
10/10✓ Branch 0 taken 462 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 462 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 462 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 462 times.
✓ Branch 7 taken 2 times.
✓ Branch 8 taken 462 times.
✓ Branch 9 taken 2 times.
|
472 | } |
| 1187 |
1/2✓ Branch 0 taken 642 times.
✗ Branch 1 not taken.
|
642 | thd->change_item_tree(expr, item_field); |
| 1188 | |||
| 1189 | // Adjust the predicate. | ||
| 1190 |
1/2✓ Branch 0 taken 642 times.
✗ Branch 1 not taken.
|
642 | return predicate->resolve_type(thd); |
| 1191 | } | ||
| 1192 | |||
| 1193 | /** | ||
| 1194 | A helper function for Item_func::gc_subst_transformer, that tries to | ||
| 1195 | substitute the given JSON_CONTAINS or JSON_OVERLAPS function for one of GCs | ||
| 1196 | from the provided list. The function checks whether there's an index with | ||
| 1197 | matching expression and whether all scalars for lookup can be coerced to | ||
| 1198 | index's GC field without errors. If so, index's GC field substitutes the | ||
| 1199 | given function, args are replaced for array of coerced values in order to | ||
| 1200 | match GC's type. substitute_gc_expression() can't be used to these functions | ||
| 1201 | as it's tailored to handle regular single-valued indexes and doesn't ensure | ||
| 1202 | correct coercion of all values to lookup in multi-valued index. | ||
| 1203 | |||
| 1204 | @param func Function to replace | ||
| 1205 | @param vals Args to replace | ||
| 1206 | @param vals_wr Json_wrapper containing array of values for index lookup | ||
| 1207 | @param gc_fields List of generated fields to look the function's substitute in | ||
| 1208 | */ | ||
| 1209 | |||
| 1210 | 261 | static void gc_subst_overlaps_contains(Item **func, Item **vals, | |
| 1211 | Json_wrapper &vals_wr, | ||
| 1212 | List<Field> *gc_fields) { | ||
| 1213 | // Field to substitute function for. NULL when no matching index was found. | ||
| 1214 | 261 | Field *found = nullptr; | |
| 1215 |
4/8✓ Branch 0 taken 261 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 261 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 261 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 261 times.
✗ Branch 7 not taken.
|
261 | assert(vals_wr.type() != enum_json_type::J_OBJECT && |
| 1216 | vals_wr.type() != enum_json_type::J_ERROR); | ||
| 1217 |
1/2✓ Branch 0 taken 261 times.
✗ Branch 1 not taken.
|
261 | THD *thd = current_thd; |
| 1218 | // Vector of coerced keys | ||
| 1219 |
1/2✓ Branch 0 taken 261 times.
✗ Branch 1 not taken.
|
261 | Json_array_ptr coerced_keys = create_dom_ptr<Json_array>(); |
| 1220 | |||
| 1221 | // Find a field that matches the expression | ||
| 1222 |
5/8✓ Branch 0 taken 261 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 261 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 399 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 373 times.
✓ Branch 7 taken 26 times.
|
399 | for (Field &fld : *gc_fields) { |
| 1223 | 373 | bool can_use_index = true; | |
| 1224 | // Check whether field has usable keys | ||
| 1225 | 373 | Key_map tkm = fld.part_of_key; | |
| 1226 | 373 | tkm.intersect(fld.table->keys_in_use_for_query); | |
| 1227 | |||
| 1228 |
7/8✓ Branch 0 taken 360 times.
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 360 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 73 times.
✓ Branch 5 taken 287 times.
✓ Branch 6 taken 86 times.
✓ Branch 7 taken 287 times.
|
422 | if (tkm.is_clear_all() || !fld.is_array()) continue; |
| 1229 |
1/2✓ Branch 0 taken 287 times.
✗ Branch 1 not taken.
|
287 | Functional_index_error_handler func_idx_err_hndl(&fld, thd); |
| 1230 | 287 | found = nullptr; | |
| 1231 | |||
| 1232 |
2/4✓ Branch 0 taken 287 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 287 times.
✗ Branch 3 not taken.
|
287 | get_gc_for_expr(*func, &fld, fld.result_type(), &found); |
| 1233 |
6/8✓ Branch 0 taken 238 times.
✓ Branch 1 taken 49 times.
✓ Branch 2 taken 238 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 238 times.
✓ Branch 6 taken 49 times.
✓ Branch 7 taken 238 times.
|
287 | if (!found || !found->is_array()) continue; |
| 1234 | 238 | Field_typed_array *afld = down_cast<Field_typed_array *>(found); | |
| 1235 | // Check that array's values can be coerced to found field's type | ||
| 1236 | uint len; | ||
| 1237 |
3/4✓ Branch 0 taken 238 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 142 times.
✓ Branch 3 taken 96 times.
|
238 | if (vals_wr.type() == enum_json_type::J_ARRAY) |
| 1238 |
1/2✓ Branch 0 taken 142 times.
✗ Branch 1 not taken.
|
142 | len = vals_wr.length(); |
| 1239 | else | ||
| 1240 | 96 | len = 1; | |
| 1241 | 238 | coerced_keys->clear(); | |
| 1242 |
2/2✓ Branch 0 taken 381 times.
✓ Branch 1 taken 235 times.
|
616 | for (uint i = 0; i < len; i++) { |
| 1243 |
1/2✓ Branch 0 taken 381 times.
✗ Branch 1 not taken.
|
381 | Json_wrapper elt = vals_wr[i]; |
| 1244 | 381 | Json_wrapper res; | |
| 1245 |
3/4✓ Branch 0 taken 381 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 378 times.
|
381 | if (afld->coerce_json_value(&elt, true, &res)) { |
| 1246 | 3 | can_use_index = false; | |
| 1247 | 3 | found = nullptr; | |
| 1248 | 3 | break; | |
| 1249 | } | ||
| 1250 |
2/4✓ Branch 0 taken 378 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 378 times.
✗ Branch 3 not taken.
|
378 | coerced_keys->append_clone(res.to_dom()); |
| 1251 |
4/4✓ Branch 0 taken 378 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 378 times.
✓ Branch 3 taken 3 times.
|
384 | } |
| 1252 |
2/2✓ Branch 0 taken 235 times.
✓ Branch 1 taken 3 times.
|
238 | if (can_use_index) break; |
| 1253 |
3/3✓ Branch 0 taken 3 times.
✓ Branch 1 taken 49 times.
✓ Branch 2 taken 235 times.
|
287 | } |
| 1254 |
2/2✓ Branch 0 taken 26 times.
✓ Branch 1 taken 235 times.
|
261 | if (!found) return; |
| 1255 | 235 | TABLE *table = found->table; | |
| 1256 |
2/4✓ Branch 0 taken 235 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 235 times.
✗ Branch 3 not taken.
|
235 | Item_field *subs_item = new Item_field(found); |
| 1257 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 235 times.
|
235 | if (!subs_item) return; |
| 1258 | auto res = make_unique_destroy_only<Json_wrapper>(thd->mem_root, | ||
| 1259 |
1/2✓ Branch 0 taken 235 times.
✗ Branch 1 not taken.
|
235 | coerced_keys.release()); |
| 1260 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 235 times.
|
235 | if (res == nullptr) return; |
| 1261 | Item_json *array_arg = | ||
| 1262 |
2/4✓ Branch 0 taken 235 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 235 times.
✗ Branch 3 not taken.
|
235 | new (thd->mem_root) Item_json(std::move(res), (*func)->item_name); |
| 1263 |
4/8✓ Branch 0 taken 235 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 235 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 235 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 235 times.
|
235 | if (!array_arg || array_arg->fix_fields(thd, nullptr)) return; |
| 1264 |
1/2✓ Branch 0 taken 235 times.
✗ Branch 1 not taken.
|
235 | table->mark_column_used(found, MARK_COLUMNS_READ); |
| 1265 |
1/2✓ Branch 0 taken 235 times.
✗ Branch 1 not taken.
|
235 | thd->change_item_tree(func, subs_item); |
| 1266 |
1/2✓ Branch 0 taken 235 times.
✗ Branch 1 not taken.
|
235 | thd->change_item_tree(vals, array_arg); |
| 1267 |
3/4✓ Branch 0 taken 235 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 235 times.
✓ Branch 3 taken 26 times.
|
261 | } |
| 1268 | |||
| 1269 | /** | ||
| 1270 | Transformer function for GC substitution. | ||
| 1271 | |||
| 1272 | @param arg List of indexed GC field | ||
| 1273 | |||
| 1274 | @return this item on successful execution, nullptr on error | ||
| 1275 | |||
| 1276 | @details This function transforms a search condition. It doesn't change | ||
| 1277 | 'this' item but rather changes its arguments. It takes list of GC fields | ||
| 1278 | and checks whether arguments of 'this' item matches them and index over | ||
| 1279 | the GC field isn't disabled with hints. If so, it replaces | ||
| 1280 | the argument with newly created Item_field which uses the matched GC field. | ||
| 1281 | The following predicates' arguments could be transformed: | ||
| 1282 | - EQ_FUNC, LT_FUNC, LE_FUNC, GE_FUNC, GT_FUNC, JSON_OVERLAPS | ||
| 1283 | - Left _or_ right argument if the opposite argument is a constant. | ||
| 1284 | - IN_FUNC, BETWEEN | ||
| 1285 | - Left argument if all other arguments are constant and of the same type. | ||
| 1286 | - MEMBER OF | ||
| 1287 | - Right argument if left argument is constant. | ||
| 1288 | - JSON_CONTAINS | ||
| 1289 | - First argument if the second argument is constant. | ||
| 1290 | |||
| 1291 | After transformation comparators are updated to take into account the new | ||
| 1292 | field. | ||
| 1293 | |||
| 1294 | Note: Range optimizer is used with multi-value indexes and it prefers | ||
| 1295 | constants. Outer references are not considered as constants in JSON functions. | ||
| 1296 | However, range optimizer supports dynamic ranges, where ranges are | ||
| 1297 | re-optimized for each row. But the range optimizer is currently not able to | ||
| 1298 | handle multi-valued indexes with dynamic ranges, hence we use only constants | ||
| 1299 | in these cases. | ||
| 1300 | |||
| 1301 | */ | ||
| 1302 | |||
| 1303 | 7339 | Item *Item_func::gc_subst_transformer(uchar *arg) { | |
| 1304 | 7339 | List<Field> *gc_fields = pointer_cast<List<Field> *>(arg); | |
| 1305 | |||
| 1306 | 363 | auto is_const_or_outer_reference = [](const Item *item) { | |
| 1307 | 363 | return ((item->used_tables() & ~(OUTER_REF_TABLE_BIT | INNER_TABLE_BIT)) == | |
| 1308 | 363 | 0); | |
| 1309 | }; | ||
| 1310 | |||
| 1311 |
7/8✓ Branch 0 taken 7339 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6327 times.
✓ Branch 3 taken 89 times.
✓ Branch 4 taken 481 times.
✓ Branch 5 taken 169 times.
✓ Branch 6 taken 112 times.
✓ Branch 7 taken 161 times.
|
7339 | switch (functype()) { |
| 1312 | 6327 | case EQ_FUNC: | |
| 1313 | case LT_FUNC: | ||
| 1314 | case LE_FUNC: | ||
| 1315 | case GE_FUNC: | ||
| 1316 | case GT_FUNC: { | ||
| 1317 | 6327 | Item **func = nullptr; | |
| 1318 | 6327 | Item *val = nullptr; | |
| 1319 | |||
| 1320 | // Check if we can substitute a function with a GC. The | ||
| 1321 | // predicate must be on the form <expr> OP <constant> or | ||
| 1322 | // <constant> OP <expr>. | ||
| 1323 |
5/6✓ Branch 0 taken 6327 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 289 times.
✓ Branch 3 taken 6038 times.
✓ Branch 4 taken 287 times.
✓ Branch 5 taken 6040 times.
|
6616 | if (args[0]->can_be_substituted_for_gc() && |
| 1324 |
3/4✓ Branch 0 taken 289 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 287 times.
✓ Branch 3 taken 2 times.
|
289 | is_const_or_outer_reference(args[1])) { |
| 1325 | 287 | func = args; | |
| 1326 | 287 | val = args[1]; | |
| 1327 |
5/6✓ Branch 0 taken 6040 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 38 times.
✓ Branch 3 taken 6002 times.
✓ Branch 4 taken 19 times.
✓ Branch 5 taken 6021 times.
|
6078 | } else if (args[1]->can_be_substituted_for_gc() && |
| 1328 |
3/4✓ Branch 0 taken 38 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 19 times.
|
38 | is_const_or_outer_reference(args[0])) { |
| 1329 | 19 | func = args + 1; | |
| 1330 | 19 | val = args[0]; | |
| 1331 | } else { | ||
| 1332 | 6021 | break; | |
| 1333 | } | ||
| 1334 | |||
| 1335 |
3/6✓ Branch 0 taken 306 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 306 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 306 times.
|
306 | if (substitute_gc_expression(func, nullptr, gc_fields, val->result_type(), |
| 1336 | this)) | ||
| 1337 | ✗ | return nullptr; /* purecov: inspected */ | |
| 1338 | 306 | break; | |
| 1339 | } | ||
| 1340 | 89 | case BETWEEN: | |
| 1341 | case IN_FUNC: { | ||
| 1342 |
3/4✓ Branch 0 taken 89 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✓ Branch 3 taken 14 times.
|
89 | if (!args[0]->can_be_substituted_for_gc()) break; |
| 1343 | |||
| 1344 | // Can only substitute if all the operands on the right-hand | ||
| 1345 | // side are constants of the same type. | ||
| 1346 |
1/2✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
|
14 | Item_result type = args[1]->result_type(); |
| 1347 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (!std::all_of( |
| 1348 |
1/2✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
|
14 | args + 1, args + arg_count, |
| 1349 | 72 | [type, is_const_or_outer_reference](const Item *item_arg) { | |
| 1350 |
1/2✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
|
72 | return is_const_or_outer_reference(item_arg) && |
| 1351 |
1/2✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
|
72 | item_arg->result_type() == type; |
| 1352 | })) { | ||
| 1353 | ✗ | break; | |
| 1354 | } | ||
| 1355 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14 times.
|
14 | if (substitute_gc_expression(args, nullptr, gc_fields, type, this)) |
| 1356 | ✗ | return nullptr; | |
| 1357 | 14 | break; | |
| 1358 | } | ||
| 1359 | 481 | case MEMBER_OF_FUNC: { | |
| 1360 |
1/2✓ Branch 0 taken 481 times.
✗ Branch 1 not taken.
|
481 | Item_result type = args[0]->result_type(); |
| 1361 | /* | ||
| 1362 | Check whether MEMBER OF is applicable for optimization: | ||
| 1363 | 1) 1st arg is constant for execution | ||
| 1364 | 2) .. and it isn't NULL, as MEMBER OF can't be used to lookup NULLs | ||
| 1365 | 3) 2nd arg can be substituted for a GC | ||
| 1366 | */ | ||
| 1367 |
1/2✓ Branch 0 taken 481 times.
✗ Branch 1 not taken.
|
481 | if (args[0]->const_for_execution() && // 1 |
| 1368 |
7/8✓ Branch 0 taken 479 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 479 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 477 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 477 times.
✓ Branch 7 taken 4 times.
|
958 | !args[0]->is_null() && // 2 |
| 1369 |
2/4✓ Branch 0 taken 477 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 477 times.
✗ Branch 3 not taken.
|
477 | args[1]->can_be_substituted_for_gc(/*array=*/true)) { // 3 |
| 1370 |
2/4✓ Branch 0 taken 477 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 477 times.
|
477 | if (substitute_gc_expression(args + 1, args, gc_fields, type, this)) |
| 1371 | ✗ | return nullptr; | |
| 1372 | } | ||
| 1373 | 481 | break; | |
| 1374 | } | ||
| 1375 | 169 | case JSON_CONTAINS: { | |
| 1376 | 169 | Json_wrapper vals_wr; | |
| 1377 | 169 | String str; | |
| 1378 | /* | ||
| 1379 | Check whether JSON_CONTAINS is applicable for optimization: | ||
| 1380 | 1) 1st arg can be substituted with a generated column | ||
| 1381 | 2) value to lookup is constant for execution | ||
| 1382 | 3) value to lookup is a proper JSON doc | ||
| 1383 | 4) value to lookup is an array or scalar | ||
| 1384 | */ | ||
| 1385 |
4/6✓ Branch 0 taken 169 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 169 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 13 times.
✓ Branch 5 taken 156 times.
|
338 | if (!args[0]->can_be_substituted_for_gc(/*array=*/true) || // 1 |
| 1386 |
3/4✓ Branch 0 taken 169 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 156 times.
|
169 | !args[1]->const_for_execution()) // 2 |
| 1387 | 13 | break; | |
| 1388 |
4/6✓ Branch 0 taken 156 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 156 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 155 times.
|
156 | if (get_json_wrapper(args, 1, &str, func_name(), &vals_wr)) { // 3 |
| 1389 | 1 | return nullptr; | |
| 1390 | } | ||
| 1391 |
3/4✓ Branch 0 taken 155 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 151 times.
|
310 | if (args[1]->null_value || |
| 1392 |
3/4✓ Branch 0 taken 155 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 151 times.
|
155 | vals_wr.type() == enum_json_type::J_OBJECT) // 4 |
| 1393 | 4 | break; | |
| 1394 |
1/2✓ Branch 0 taken 151 times.
✗ Branch 1 not taken.
|
151 | gc_subst_overlaps_contains(args, args + 1, vals_wr, gc_fields); |
| 1395 | 151 | break; | |
| 1396 |
4/4✓ Branch 0 taken 168 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 168 times.
✓ Branch 3 taken 1 times.
|
338 | } |
| 1397 | 112 | case JSON_OVERLAPS: { | |
| 1398 | 112 | Item **func = nullptr; | |
| 1399 | 112 | int vals = -1; | |
| 1400 | |||
| 1401 | /* | ||
| 1402 | Check whether JSON_OVERLAPS is applicable for optimization: | ||
| 1403 | 1) One argument is constant for execution | ||
| 1404 | 2) The other argument can be substituted with a generated column | ||
| 1405 | 3) value to lookup is a proper JSON doc | ||
| 1406 | 4) value to lookup is an array or scalar | ||
| 1407 | */ | ||
| 1408 |
5/6✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 104 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 91 times.
✓ Branch 5 taken 21 times.
|
216 | if (args[0]->can_be_substituted_for_gc(/*array=*/true) && // 2 |
| 1409 |
3/4✓ Branch 0 taken 104 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 91 times.
✓ Branch 3 taken 13 times.
|
104 | args[1]->const_for_execution()) { // 1 |
| 1410 | 91 | func = args; | |
| 1411 | 91 | vals = 1; | |
| 1412 |
3/6✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 21 times.
✗ Branch 5 not taken.
|
42 | } else if (args[1]->can_be_substituted_for_gc(/*array=*/true) && // 2 |
| 1413 |
2/4✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
|
21 | args[0]->const_for_execution()) { // 1 |
| 1414 | 21 | func = args + 1; | |
| 1415 | 21 | vals = 0; | |
| 1416 | } else { | ||
| 1417 | 111 | break; | |
| 1418 | } | ||
| 1419 | |||
| 1420 | 112 | Json_wrapper vals_wr; | |
| 1421 | 112 | String str; | |
| 1422 |
4/6✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 112 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 111 times.
|
112 | if (get_json_wrapper(args, vals, &str, func_name(), &vals_wr)) { // 3 |
| 1423 | 1 | return nullptr; | |
| 1424 | } | ||
| 1425 |
3/4✓ Branch 0 taken 111 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 110 times.
|
222 | if (args[vals]->null_value || |
| 1426 |
3/4✓ Branch 0 taken 111 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 110 times.
|
111 | vals_wr.type() == enum_json_type::J_OBJECT) // 4 |
| 1427 | 1 | break; | |
| 1428 |
1/2✓ Branch 0 taken 110 times.
✗ Branch 1 not taken.
|
110 | gc_subst_overlaps_contains(func, args + vals, vals_wr, gc_fields); |
| 1429 | 110 | break; | |
| 1430 |
4/4✓ Branch 0 taken 1 times.
✓ Branch 1 taken 111 times.
✓ Branch 2 taken 111 times.
✓ Branch 3 taken 1 times.
|
224 | } |
| 1431 | 161 | default: | |
| 1432 | 161 | break; | |
| 1433 | } | ||
| 1434 | 7337 | return this; | |
| 1435 | } | ||
| 1436 | |||
| 1437 | 854 | double Item_int_func::val_real() { | |
| 1438 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 854 times.
|
854 | assert(fixed == 1); |
| 1439 | |||
| 1440 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 850 times.
|
854 | return unsigned_flag ? (double)((ulonglong)val_int()) : (double)val_int(); |
| 1441 | } | ||
| 1442 | |||
| 1443 | 4024 | String *Item_int_func::val_str(String *str) { | |
| 1444 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4024 times.
|
4024 | assert(fixed == 1); |
| 1445 | 4024 | longlong nr = val_int(); | |
| 1446 |
2/2✓ Branch 0 taken 365 times.
✓ Branch 1 taken 3659 times.
|
4024 | if (null_value) return nullptr; |
| 1447 | 3659 | str->set_int(nr, unsigned_flag, collation.collation); | |
| 1448 | 3659 | return str; | |
| 1449 | } | ||
| 1450 | |||
| 1451 | 10214 | bool Item_func_connection_id::itemize(Parse_context *pc, Item **res) { | |
| 1452 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10214 times.
|
10214 | if (skip_itemize(res)) return false; |
| 1453 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10215 times.
|
10214 | if (super::itemize(pc, res)) return true; |
| 1454 | 10215 | pc->thd->lex->safe_to_cache_query = false; | |
| 1455 | 10215 | return false; | |
| 1456 | } | ||
| 1457 | |||
| 1458 | 2398 | bool Item_func_connection_id::resolve_type(THD *thd) { | |
| 1459 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2398 times.
|
2398 | if (Item_int_func::resolve_type(thd)) return true; |
| 1460 | 2398 | unsigned_flag = true; | |
| 1461 | 2398 | return false; | |
| 1462 | } | ||
| 1463 | |||
| 1464 | 2397 | bool Item_func_connection_id::fix_fields(THD *thd, Item **ref) { | |
| 1465 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2398 times.
|
2397 | if (Item_int_func::fix_fields(thd, ref)) return true; |
| 1466 | 2398 | thd->thread_specific_used = true; | |
| 1467 | 2398 | return false; | |
| 1468 | } | ||
| 1469 | |||
| 1470 | 6257 | longlong Item_func_connection_id::val_int() { | |
| 1471 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6257 times.
|
6257 | assert(fixed); |
| 1472 | 6257 | return current_thd->variables.pseudo_thread_id; | |
| 1473 | } | ||
| 1474 | |||
| 1475 | /** | ||
| 1476 | Check arguments to determine the data type for a numeric | ||
| 1477 | function of two arguments. | ||
| 1478 | */ | ||
| 1479 | |||
| 1480 | 2583631 | void Item_num_op::set_numeric_type(void) { | |
| 1481 |
1/2✓ Branch 0 taken 2583663 times.
✗ Branch 1 not taken.
|
2583631 | DBUG_TRACE; |
| 1482 |
3/10✓ Branch 0 taken 2583655 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2583660 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2583660 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
2583663 | DBUG_PRINT("info", ("name %s", func_name())); |
| 1483 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2583658 times.
|
2583658 | assert(arg_count == 2); |
| 1484 |
1/2✓ Branch 0 taken 2583656 times.
✗ Branch 1 not taken.
|
2583658 | Item_result r0 = args[0]->numeric_context_result_type(); |
| 1485 |
1/2✓ Branch 0 taken 2583647 times.
✗ Branch 1 not taken.
|
2583656 | Item_result r1 = args[1]->numeric_context_result_type(); |
| 1486 | |||
| 1487 |
2/4✓ Branch 0 taken 2583649 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2583652 times.
✗ Branch 3 not taken.
|
2583647 | assert(r0 != STRING_RESULT && r1 != STRING_RESULT); |
| 1488 | |||
| 1489 |
4/4✓ Branch 0 taken 2467950 times.
✓ Branch 1 taken 115702 times.
✓ Branch 2 taken 43827 times.
✓ Branch 3 taken 2424123 times.
|
2583652 | if (r0 == REAL_RESULT || r1 == REAL_RESULT) { |
| 1490 | /* | ||
| 1491 | Since DATE/TIME/DATETIME data types return INT_RESULT/DECIMAL_RESULT | ||
| 1492 | type codes, we should never get to here when both fields are temporal. | ||
| 1493 | */ | ||
| 1494 |
3/4✓ Branch 0 taken 66 times.
✓ Branch 1 taken 159448 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 66 times.
|
159529 | assert(!args[0]->is_temporal() || !args[1]->is_temporal()); |
| 1495 | 159514 | set_data_type(MYSQL_TYPE_DOUBLE); | |
| 1496 | 159514 | hybrid_type = REAL_RESULT; | |
| 1497 |
1/2✓ Branch 0 taken 159514 times.
✗ Branch 1 not taken.
|
159514 | aggregate_float_properties(args, arg_count); |
| 1498 | 159514 | max_length = float_length(decimals); | |
| 1499 |
4/4✓ Branch 0 taken 2313699 times.
✓ Branch 1 taken 110424 times.
✓ Branch 2 taken 20663 times.
✓ Branch 3 taken 2293036 times.
|
2424123 | } else if (r0 == DECIMAL_RESULT || r1 == DECIMAL_RESULT) { |
| 1500 | 131087 | set_data_type(MYSQL_TYPE_NEWDECIMAL); | |
| 1501 | 131094 | hybrid_type = DECIMAL_RESULT; | |
| 1502 |
1/2✓ Branch 0 taken 131090 times.
✗ Branch 1 not taken.
|
131094 | result_precision(); |
| 1503 | } else { | ||
| 1504 |
4/4✓ Branch 0 taken 2293031 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 2293030 times.
✓ Branch 3 taken 1 times.
|
2293036 | assert(r0 == INT_RESULT && r1 == INT_RESULT); |
| 1505 | 2293030 | set_data_type(MYSQL_TYPE_LONGLONG); | |
| 1506 | 2293032 | decimals = 0; | |
| 1507 | 2293032 | hybrid_type = INT_RESULT; | |
| 1508 |
1/2✓ Branch 0 taken 2293037 times.
✗ Branch 1 not taken.
|
2293032 | result_precision(); |
| 1509 | } | ||
| 1510 |
3/14✓ Branch 0 taken 2583644 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2583645 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2583645 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
2583641 | DBUG_PRINT("info", ("Type: %s", (hybrid_type == REAL_RESULT |
| 1511 | ? "REAL_RESULT" | ||
| 1512 | : hybrid_type == DECIMAL_RESULT | ||
| 1513 | ? "DECIMAL_RESULT" | ||
| 1514 | : hybrid_type == INT_RESULT | ||
| 1515 | ? "INT_RESULT" | ||
| 1516 | : "--ILLEGAL!!!--"))); | ||
| 1517 | 2583645 | } | |
| 1518 | |||
| 1519 | /** | ||
| 1520 | Set data type for a numeric function with one argument | ||
| 1521 | (can be also used by a numeric function with many arguments, if the result | ||
| 1522 | type depends only on the first argument) | ||
| 1523 | */ | ||
| 1524 | |||
| 1525 | 186641 | void Item_func_num1::set_numeric_type() { | |
| 1526 |
1/2✓ Branch 0 taken 186641 times.
✗ Branch 1 not taken.
|
186641 | DBUG_TRACE; |
| 1527 |
3/10✓ Branch 0 taken 186641 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 186641 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 186641 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
186641 | DBUG_PRINT("info", ("name %s", func_name())); |
| 1528 |
4/6✓ Branch 0 taken 186641 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 182806 times.
✓ Branch 3 taken 1890 times.
✓ Branch 4 taken 1945 times.
✗ Branch 5 not taken.
|
186641 | switch (hybrid_type = args[0]->result_type()) { |
| 1529 | 182806 | case INT_RESULT: | |
| 1530 | 182806 | set_data_type(MYSQL_TYPE_LONGLONG); | |
| 1531 | 182806 | unsigned_flag = args[0]->unsigned_flag; | |
| 1532 | 182806 | break; | |
| 1533 | 1890 | case STRING_RESULT: | |
| 1534 | case REAL_RESULT: | ||
| 1535 | 1890 | set_data_type(MYSQL_TYPE_DOUBLE); | |
| 1536 | 1890 | hybrid_type = REAL_RESULT; | |
| 1537 | 1890 | max_length = float_length(decimals); | |
| 1538 | 1890 | break; | |
| 1539 | 1945 | case DECIMAL_RESULT: | |
| 1540 | 1945 | set_data_type(MYSQL_TYPE_NEWDECIMAL); | |
| 1541 | 1945 | unsigned_flag = args[0]->unsigned_flag; | |
| 1542 | 1945 | break; | |
| 1543 | ✗ | default: | |
| 1544 | ✗ | assert(0); | |
| 1545 | } | ||
| 1546 |
3/14✓ Branch 0 taken 186641 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 186641 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 186641 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
186641 | DBUG_PRINT("info", ("Type: %s", (hybrid_type == REAL_RESULT |
| 1547 | ? "REAL_RESULT" | ||
| 1548 | : hybrid_type == DECIMAL_RESULT | ||
| 1549 | ? "DECIMAL_RESULT" | ||
| 1550 | : hybrid_type == INT_RESULT | ||
| 1551 | ? "INT_RESULT" | ||
| 1552 | : "--ILLEGAL!!!--"))); | ||
| 1553 | 186641 | } | |
| 1554 | |||
| 1555 | 9390 | void Item_func_num1::fix_num_length_and_dec() { | |
| 1556 | 9390 | decimals = args[0]->decimals; | |
| 1557 | 9390 | max_length = args[0]->max_length; | |
| 1558 | 9390 | } | |
| 1559 | |||
| 1560 | /* | ||
| 1561 | Reject geometry arguments, should be called in resolve_type() for | ||
| 1562 | SQL functions/operators where geometries are not suitable as operands. | ||
| 1563 | */ | ||
| 1564 | 5995212 | bool reject_geometry_args(uint arg_count, Item **args, Item_result_field *me) { | |
| 1565 | /* | ||
| 1566 | We want to make sure the operands are not GEOMETRY strings because | ||
| 1567 | it's meaningless for them to participate in arithmetic and/or numerical | ||
| 1568 | calculations. | ||
| 1569 | |||
| 1570 | When a variable holds a MySQL Geometry byte string, it is regarded as a | ||
| 1571 | string rather than a MYSQL_TYPE_GEOMETRY, so here we can't catch an illegal | ||
| 1572 | variable argument which was assigned with a geometry. | ||
| 1573 | |||
| 1574 | Item::data_type() requires the item not be of ROW_RESULT, since a row | ||
| 1575 | isn't a field. | ||
| 1576 | */ | ||
| 1577 |
2/2✓ Branch 0 taken 10008911 times.
✓ Branch 1 taken 5995126 times.
|
16004037 | for (uint i = 0; i < arg_count; i++) { |
| 1578 |
6/6✓ Branch 0 taken 10008759 times.
✓ Branch 1 taken 164 times.
✓ Branch 2 taken 104 times.
✓ Branch 3 taken 10008661 times.
✓ Branch 4 taken 104 times.
✓ Branch 5 taken 10008825 times.
|
20017676 | if (args[i]->result_type() != ROW_RESULT && |
| 1579 | 10008759 | args[i]->data_type() == MYSQL_TYPE_GEOMETRY) { | |
| 1580 | 104 | my_error(ER_WRONG_ARGUMENTS, MYF(0), me->func_name()); | |
| 1581 | 104 | return true; | |
| 1582 | } | ||
| 1583 | } | ||
| 1584 | |||
| 1585 | 5995126 | return false; | |
| 1586 | } | ||
| 1587 | |||
| 1588 | /** | ||
| 1589 | Go through the arguments of a function and check if any of them are | ||
| 1590 | JSON. If a JSON argument is found, raise a warning saying that this | ||
| 1591 | operation is not supported yet. This function is used to notify | ||
| 1592 | users that they are comparing JSON values using a mechanism that has | ||
| 1593 | not yet been updated to use the JSON comparator. JSON values are | ||
| 1594 | typically handled as strings in that case. | ||
| 1595 | |||
| 1596 | @param arg_count the number of arguments | ||
| 1597 | @param args the arguments to go through looking for JSON values | ||
| 1598 | @param msg the message that explains what is not supported | ||
| 1599 | */ | ||
| 1600 | 41599 | void unsupported_json_comparison(size_t arg_count, Item **args, | |
| 1601 | const char *msg) { | ||
| 1602 |
2/2✓ Branch 0 taken 121840 times.
✓ Branch 1 taken 41587 times.
|
163427 | for (size_t i = 0; i < arg_count; ++i) { |
| 1603 |
6/6✓ Branch 0 taken 3876 times.
✓ Branch 1 taken 117964 times.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 3864 times.
✓ Branch 4 taken 11 times.
✓ Branch 5 taken 121828 times.
|
125715 | if (args[i]->result_type() == STRING_RESULT && |
| 1604 | 3876 | args[i]->data_type() == MYSQL_TYPE_JSON) { | |
| 1605 | 11 | push_warning_printf(current_thd, Sql_condition::SL_WARNING, | |
| 1606 | ER_NOT_SUPPORTED_YET, | ||
| 1607 | 11 | ER_THD(current_thd, ER_NOT_SUPPORTED_YET), msg); | |
| 1608 | 11 | break; | |
| 1609 | } | ||
| 1610 | } | ||
| 1611 | 41598 | } | |
| 1612 | |||
| 1613 | 2871882 | bool Item_func_numhybrid::resolve_type(THD *thd) { | |
| 1614 |
3/4✓ Branch 0 taken 2619941 times.
✓ Branch 1 taken 251941 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2619941 times.
|
2871882 | assert(arg_count == 1 || arg_count == 2); |
| 1615 | /* | ||
| 1616 | If no arguments have type information, return and trust | ||
| 1617 | propagate_type() to assign data types later. | ||
| 1618 | If some argument has type information, propagate the same type to | ||
| 1619 | the other argument. | ||
| 1620 | */ | ||
| 1621 |
2/2✓ Branch 0 taken 251942 times.
✓ Branch 1 taken 2619940 times.
|
2871882 | if (arg_count == 1) { |
| 1622 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 251931 times.
|
251942 | if (args[0]->data_type() == MYSQL_TYPE_INVALID) return false; |
| 1623 | } else { | ||
| 1624 |
6/6✓ Branch 0 taken 49 times.
✓ Branch 1 taken 2619895 times.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 33 times.
✓ Branch 4 taken 18 times.
✓ Branch 5 taken 2619928 times.
|
2619991 | if (args[0]->data_type() == MYSQL_TYPE_INVALID && |
| 1625 | 49 | args[1]->data_type() == MYSQL_TYPE_INVALID) | |
| 1626 | 18 | return false; | |
| 1627 | |||
| 1628 |
2/2✓ Branch 0 taken 33 times.
✓ Branch 1 taken 2619901 times.
|
2619928 | if (args[0]->data_type() == MYSQL_TYPE_INVALID) { |
| 1629 |
2/4✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33 times.
|
33 | if (args[0]->propagate_type(thd, Type_properties(*args[1]))) return true; |
| 1630 |
2/2✓ Branch 0 taken 274 times.
✓ Branch 1 taken 2619627 times.
|
2619901 | } else if (args[1]->data_type() == MYSQL_TYPE_INVALID) { |
| 1631 |
2/4✓ Branch 0 taken 274 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 274 times.
|
274 | if (args[1]->propagate_type(thd, Type_properties(*args[0]))) return true; |
| 1632 | } | ||
| 1633 | } | ||
| 1634 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2871871 times.
|
2871865 | if (resolve_type_inner(thd)) return true; |
| 1635 | 2871871 | return reject_geometry_args(arg_count, args, this); | |
| 1636 | } | ||
| 1637 | |||
| 1638 | 2806579 | bool Item_func_numhybrid::resolve_type_inner(THD *) { | |
| 1639 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2806592 times.
|
2806579 | assert(args[0]->data_type() != MYSQL_TYPE_INVALID); |
| 1640 |
3/4✓ Branch 0 taken 2619955 times.
✓ Branch 1 taken 186637 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2619951 times.
|
2806592 | assert(arg_count == 1 || args[1]->data_type() != MYSQL_TYPE_INVALID); |
| 1641 | 2806588 | fix_num_length_and_dec(); | |
| 1642 | 2806578 | set_numeric_type(); | |
| 1643 | 2806601 | return false; | |
| 1644 | } | ||
| 1645 | |||
| 1646 | 8207827 | String *Item_func_numhybrid::val_str(String *str) { | |
| 1647 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8207827 times.
|
8207827 | assert(fixed == 1); |
| 1648 |
5/5✓ Branch 0 taken 29183 times.
✓ Branch 1 taken 246332 times.
✓ Branch 2 taken 17494 times.
✓ Branch 3 taken 7914813 times.
✓ Branch 4 taken 5 times.
|
8207827 | switch (hybrid_type) { |
| 1649 | 29183 | case DECIMAL_RESULT: { | |
| 1650 | 29183 | my_decimal decimal_value, *val; | |
| 1651 |
3/4✓ Branch 0 taken 29183 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5257 times.
✓ Branch 3 taken 23926 times.
|
29183 | if (!(val = decimal_op(&decimal_value))) return nullptr; // null is set |
| 1652 |
1/2✓ Branch 0 taken 23926 times.
✗ Branch 1 not taken.
|
23926 | my_decimal_round(E_DEC_FATAL_ERROR, val, decimals, false, val); |
| 1653 | 23926 | str->set_charset(collation.collation); | |
| 1654 |
1/2✓ Branch 0 taken 23926 times.
✗ Branch 1 not taken.
|
23926 | my_decimal2string(E_DEC_FATAL_ERROR, val, str); |
| 1655 | 23926 | break; | |
| 1656 |
2/2✓ Branch 0 taken 5257 times.
✓ Branch 1 taken 23926 times.
|
29183 | } |
| 1657 | 246332 | case INT_RESULT: { | |
| 1658 | 246332 | longlong nr = int_op(); | |
| 1659 |
2/2✓ Branch 0 taken 40 times.
✓ Branch 1 taken 246301 times.
|
246341 | if (null_value) return nullptr; /* purecov: inspected */ |
| 1660 | 246301 | str->set_int(nr, unsigned_flag, collation.collation); | |
| 1661 | 246304 | break; | |
| 1662 | } | ||
| 1663 | 17494 | case REAL_RESULT: { | |
| 1664 | 17494 | double nr = real_op(); | |
| 1665 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 17489 times.
|
17494 | if (null_value) return nullptr; /* purecov: inspected */ |
| 1666 | 17489 | str->set_real(nr, decimals, collation.collation); | |
| 1667 | 17489 | break; | |
| 1668 | } | ||
| 1669 | 7914813 | case STRING_RESULT: | |
| 1670 |
4/4✓ Branch 0 taken 45 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 7914747 times.
|
7914813 | switch (data_type()) { |
| 1671 | 45 | case MYSQL_TYPE_DATETIME: | |
| 1672 | case MYSQL_TYPE_TIMESTAMP: | ||
| 1673 | 45 | return val_string_from_datetime(str); | |
| 1674 | 16 | case MYSQL_TYPE_DATE: | |
| 1675 | 16 | return val_string_from_date(str); | |
| 1676 | 5 | case MYSQL_TYPE_TIME: | |
| 1677 | 5 | return val_string_from_time(str); | |
| 1678 | 7914747 | default: | |
| 1679 | 7914747 | break; | |
| 1680 | } | ||
| 1681 | 7914747 | return str_op(&str_value); | |
| 1682 | 5 | default: | |
| 1683 | 5 | assert(0); | |
| 1684 | } | ||
| 1685 | 287719 | return str; | |
| 1686 | } | ||
| 1687 | |||
| 1688 | 6199417 | double Item_func_numhybrid::val_real() { | |
| 1689 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6199417 times.
|
6199417 | assert(fixed == 1); |
| 1690 |
4/5✓ Branch 0 taken 329716 times.
✓ Branch 1 taken 212275 times.
✓ Branch 2 taken 5657409 times.
✓ Branch 3 taken 18 times.
✗ Branch 4 not taken.
|
6199417 | switch (hybrid_type) { |
| 1691 | 329716 | case DECIMAL_RESULT: { | |
| 1692 | 329716 | my_decimal decimal_value, *val; | |
| 1693 | double result; | ||
| 1694 |
3/4✓ Branch 0 taken 329716 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 100 times.
✓ Branch 3 taken 329616 times.
|
329716 | if (!(val = decimal_op(&decimal_value))) return 0.0; // null is set |
| 1695 |
1/2✓ Branch 0 taken 329616 times.
✗ Branch 1 not taken.
|
329616 | my_decimal2double(E_DEC_FATAL_ERROR, val, &result); |
| 1696 | 329616 | return result; | |
| 1697 | 329716 | } | |
| 1698 | 212275 | case INT_RESULT: { | |
| 1699 | 212275 | longlong result = int_op(); | |
| 1700 |
2/2✓ Branch 0 taken 2285 times.
✓ Branch 1 taken 209990 times.
|
212275 | return unsigned_flag ? (double)((ulonglong)result) : (double)result; |
| 1701 | } | ||
| 1702 | 5657409 | case REAL_RESULT: | |
| 1703 | 5657409 | return real_op(); | |
| 1704 | 18 | case STRING_RESULT: { | |
| 1705 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 14 times.
|
18 | switch (data_type()) { |
| 1706 | 4 | case MYSQL_TYPE_TIME: | |
| 1707 | case MYSQL_TYPE_DATE: | ||
| 1708 | case MYSQL_TYPE_DATETIME: | ||
| 1709 | case MYSQL_TYPE_TIMESTAMP: | ||
| 1710 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | return val_real_from_decimal(); |
| 1711 | 14 | default: | |
| 1712 | 14 | break; | |
| 1713 | } | ||
| 1714 | const char *end_not_used; | ||
| 1715 | int err_not_used; | ||
| 1716 |
1/2✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
|
14 | String *res = str_op(&str_value); |
| 1717 |
3/4✓ Branch 0 taken 5 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
14 | return (res ? my_strntod(res->charset(), res->ptr(), res->length(), |
| 1718 | &end_not_used, &err_not_used) | ||
| 1719 | 14 | : 0.0); | |
| 1720 | } | ||
| 1721 | ✗ | default: | |
| 1722 | ✗ | assert(0); | |
| 1723 | } | ||
| 1724 | return 0.0; | ||
| 1725 | } | ||
| 1726 | |||
| 1727 | 90678543 | longlong Item_func_numhybrid::val_int() { | |
| 1728 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 90678543 times.
|
90678543 | assert(fixed == 1); |
| 1729 |
4/5✓ Branch 0 taken 1118859 times.
✓ Branch 1 taken 89516995 times.
✓ Branch 2 taken 42741 times.
✓ Branch 3 taken 5 times.
✗ Branch 4 not taken.
|
90678543 | switch (hybrid_type) { |
| 1730 | 1118859 | case DECIMAL_RESULT: { | |
| 1731 | 1118859 | my_decimal decimal_value, *val; | |
| 1732 |
3/4✓ Branch 0 taken 1118859 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 1118849 times.
|
1118859 | if (!(val = decimal_op(&decimal_value))) return 0; // null is set |
| 1733 | longlong result; | ||
| 1734 |
1/2✓ Branch 0 taken 1118849 times.
✗ Branch 1 not taken.
|
1118849 | my_decimal2int(E_DEC_FATAL_ERROR, val, unsigned_flag, &result); |
| 1735 | 1118849 | return result; | |
| 1736 | 1118859 | } | |
| 1737 | 89516995 | case INT_RESULT: | |
| 1738 | 89516995 | return int_op(); | |
| 1739 | 42741 | case REAL_RESULT: { | |
| 1740 | 42741 | return llrint_with_overflow_check(real_op()); | |
| 1741 | } | ||
| 1742 | 5 | case STRING_RESULT: { | |
| 1743 |
4/4✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
|
5 | switch (data_type()) { |
| 1744 | 1 | case MYSQL_TYPE_DATE: | |
| 1745 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | return val_int_from_date(); |
| 1746 | 2 | case MYSQL_TYPE_DATETIME: | |
| 1747 | case MYSQL_TYPE_TIMESTAMP: | ||
| 1748 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | return val_int_from_datetime(); |
| 1749 | 1 | case MYSQL_TYPE_TIME: | |
| 1750 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | return val_int_from_time(); |
| 1751 | 1 | default: | |
| 1752 | 1 | break; | |
| 1753 | } | ||
| 1754 | int err_not_used; | ||
| 1755 | String *res; | ||
| 1756 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
|
1 | if (!(res = str_op(&str_value))) return 0; |
| 1757 | |||
| 1758 | 1 | const char *end = res->ptr() + res->length(); | |
| 1759 | 1 | const CHARSET_INFO *cs = res->charset(); | |
| 1760 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | return (*(cs->cset->strtoll10))(cs, res->ptr(), &end, &err_not_used); |
| 1761 | } | ||
| 1762 | ✗ | default: | |
| 1763 | ✗ | assert(0); | |
| 1764 | } | ||
| 1765 | return 0; | ||
| 1766 | } | ||
| 1767 | |||
| 1768 | 2528730 | my_decimal *Item_func_numhybrid::val_decimal(my_decimal *decimal_value) { | |
| 1769 | 2528730 | my_decimal *val = decimal_value; | |
| 1770 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2528730 times.
|
2528730 | assert(fixed == 1); |
| 1771 |
4/5✓ Branch 0 taken 2052252 times.
✓ Branch 1 taken 476338 times.
✓ Branch 2 taken 117 times.
✓ Branch 3 taken 24 times.
✗ Branch 4 not taken.
|
2528730 | switch (hybrid_type) { |
| 1772 | 2052252 | case DECIMAL_RESULT: | |
| 1773 | 2052252 | val = decimal_op(decimal_value); | |
| 1774 | 2052263 | break; | |
| 1775 | 476338 | case INT_RESULT: { | |
| 1776 | 476338 | longlong result = int_op(); | |
| 1777 | 476338 | int2my_decimal(E_DEC_FATAL_ERROR, result, unsigned_flag, decimal_value); | |
| 1778 | 476338 | break; | |
| 1779 | } | ||
| 1780 | 117 | case REAL_RESULT: { | |
| 1781 | 117 | double result = real_op(); | |
| 1782 | 117 | double2my_decimal(E_DEC_FATAL_ERROR, result, decimal_value); | |
| 1783 | 117 | break; | |
| 1784 | } | ||
| 1785 | 24 | case STRING_RESULT: { | |
| 1786 |
3/3✓ Branch 0 taken 9 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 14 times.
|
24 | switch (data_type()) { |
| 1787 | 9 | case MYSQL_TYPE_DATE: | |
| 1788 | case MYSQL_TYPE_DATETIME: | ||
| 1789 | case MYSQL_TYPE_TIMESTAMP: | ||
| 1790 | 9 | return val_decimal_from_date(decimal_value); | |
| 1791 | 1 | case MYSQL_TYPE_TIME: | |
| 1792 | 1 | return val_decimal_from_time(decimal_value); | |
| 1793 | 14 | default: | |
| 1794 | 14 | break; | |
| 1795 | } | ||
| 1796 | String *res; | ||
| 1797 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 3 times.
|
14 | if (!(res = str_op(&str_value))) return nullptr; |
| 1798 | |||
| 1799 | 3 | str2my_decimal(E_DEC_FATAL_ERROR, res->ptr(), res->length(), | |
| 1800 | res->charset(), decimal_value); | ||
| 1801 | 2 | break; | |
| 1802 | } | ||
| 1803 | ✗ | case ROW_RESULT: | |
| 1804 | default: | ||
| 1805 | ✗ | assert(0); | |
| 1806 | } | ||
| 1807 | 2528720 | return val; | |
| 1808 | } | ||
| 1809 | |||
| 1810 | 224 | bool Item_func_numhybrid::get_date(MYSQL_TIME *ltime, | |
| 1811 | my_time_flags_t fuzzydate) { | ||
| 1812 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 224 times.
|
224 | assert(fixed == 1); |
| 1813 |
4/4✓ Branch 0 taken 182 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 37 times.
|
224 | switch (data_type()) { |
| 1814 | 182 | case MYSQL_TYPE_DATE: | |
| 1815 | case MYSQL_TYPE_DATETIME: | ||
| 1816 | case MYSQL_TYPE_TIMESTAMP: | ||
| 1817 | 182 | return date_op(ltime, fuzzydate); | |
| 1818 | 4 | case MYSQL_TYPE_TIME: | |
| 1819 | 4 | return get_date_from_time(ltime); | |
| 1820 | 1 | case MYSQL_TYPE_YEAR: | |
| 1821 | 1 | return get_date_from_int(ltime, fuzzydate); | |
| 1822 | 37 | default: | |
| 1823 | 37 | return Item::get_date_from_non_temporal(ltime, fuzzydate); | |
| 1824 | } | ||
| 1825 | } | ||
| 1826 | |||
| 1827 | 44 | bool Item_func_numhybrid::get_time(MYSQL_TIME *ltime) { | |
| 1828 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 44 times.
|
44 | assert(fixed == 1); |
| 1829 |
5/5✓ Branch 0 taken 20 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 16 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 5 times.
|
44 | switch (data_type()) { |
| 1830 | 20 | case MYSQL_TYPE_TIME: | |
| 1831 | 20 | return time_op(ltime); | |
| 1832 | 2 | case MYSQL_TYPE_DATE: | |
| 1833 | 2 | return get_time_from_date(ltime); | |
| 1834 | 16 | case MYSQL_TYPE_DATETIME: | |
| 1835 | case MYSQL_TYPE_TIMESTAMP: | ||
| 1836 | 16 | return get_time_from_datetime(ltime); | |
| 1837 | 1 | case MYSQL_TYPE_YEAR: | |
| 1838 | 1 | return get_time_from_int(ltime); | |
| 1839 | 5 | default: | |
| 1840 | 5 | return Item::get_time_from_non_temporal(ltime); | |
| 1841 | } | ||
| 1842 | } | ||
| 1843 | |||
| 1844 | 126 | void Item_typecast_signed::print(const THD *thd, String *str, | |
| 1845 | enum_query_type query_type) const { | ||
| 1846 | 126 | str->append(STRING_WITH_LEN("cast(")); | |
| 1847 | 126 | args[0]->print(thd, str, query_type); | |
| 1848 | 126 | str->append(STRING_WITH_LEN(" as signed)")); | |
| 1849 | 126 | } | |
| 1850 | |||
| 1851 | 29502 | bool Item_typecast_signed::resolve_type(THD *thd) { | |
| 1852 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 29501 times.
|
29502 | if (reject_geometry_args(arg_count, args, this)) return true; |
| 1853 | 29501 | return args[0]->propagate_type(thd, MYSQL_TYPE_LONGLONG, false, true); | |
| 1854 | } | ||
| 1855 | |||
| 1856 | 200994 | static longlong val_int_from_str(Item *item, bool unsigned_flag, | |
| 1857 | bool *null_value) { | ||
| 1858 | /* | ||
| 1859 | For a string result, we must first get the string and then convert it | ||
| 1860 | to a longlong | ||
| 1861 | */ | ||
| 1862 | 200994 | StringBuffer<MAX_FIELD_WIDTH> tmp; | |
| 1863 |
1/2✓ Branch 0 taken 200994 times.
✗ Branch 1 not taken.
|
200994 | const String *res = item->val_str(&tmp); |
| 1864 | 200994 | *null_value = item->null_value; | |
| 1865 |
2/2✓ Branch 0 taken 108 times.
✓ Branch 1 taken 200886 times.
|
200994 | if (*null_value) return 0; |
| 1866 | |||
| 1867 | 200886 | size_t length = res->length(); | |
| 1868 | 200886 | const char *start = res->ptr(); | |
| 1869 | 200886 | const char *end = start + length; | |
| 1870 |
1/2✓ Branch 0 taken 200886 times.
✗ Branch 1 not taken.
|
200886 | return longlong_from_string_with_check(res->charset(), start, end, |
| 1871 | 200886 | unsigned_flag); | |
| 1872 | 200994 | } | |
| 1873 | |||
| 1874 | 201205 | longlong Item_typecast_signed::val_int() { | |
| 1875 | longlong value; | ||
| 1876 | |||
| 1877 |
6/6✓ Branch 0 taken 200883 times.
✓ Branch 1 taken 322 times.
✓ Branch 2 taken 174 times.
✓ Branch 3 taken 200709 times.
✓ Branch 4 taken 496 times.
✓ Branch 5 taken 200709 times.
|
201205 | if (args[0]->cast_to_int_type() != STRING_RESULT || args[0]->is_temporal()) { |
| 1878 | 496 | value = args[0]->val_int(); | |
| 1879 | 496 | null_value = args[0]->null_value; | |
| 1880 | } else { | ||
| 1881 | 200709 | value = val_int_from_str(args[0], unsigned_flag, &null_value); | |
| 1882 | } | ||
| 1883 | |||
| 1884 | #ifndef NDEBUG | ||
| 1885 |
2/2✓ Branch 0 taken 95 times.
✓ Branch 1 taken 201110 times.
|
201205 | if (null_value) { |
| 1886 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 95 times.
|
95 | assert(is_nullable()); |
| 1887 |
2/2✓ Branch 0 taken 200957 times.
✓ Branch 1 taken 153 times.
|
201110 | } else if (value >= 0) { |
| 1888 | 200957 | const int digits = count_digits(static_cast<ulonglong>(value)); | |
| 1889 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200957 times.
|
200957 | assert(digits <= decimal_int_part()); |
| 1890 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200957 times.
|
200957 | assert(static_cast<unsigned>(digits) <= max_length); |
| 1891 | } else { | ||
| 1892 | const int digits = | ||
| 1893 | 153 | count_digits(ulonglong{0} - static_cast<ulonglong>(value)); | |
| 1894 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 153 times.
|
153 | assert(digits <= decimal_int_part()); |
| 1895 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 153 times.
|
153 | assert(static_cast<unsigned>(digits) + 1 <= max_length); |
| 1896 | } | ||
| 1897 | #endif | ||
| 1898 | |||
| 1899 | 201205 | return value; | |
| 1900 | } | ||
| 1901 | |||
| 1902 | 12887 | void Item_typecast_unsigned::print(const THD *thd, String *str, | |
| 1903 | enum_query_type query_type) const { | ||
| 1904 | 12887 | str->append(STRING_WITH_LEN("cast(")); | |
| 1905 | 12887 | args[0]->print(thd, str, query_type); | |
| 1906 | 12887 | str->append(STRING_WITH_LEN(" as unsigned)")); | |
| 1907 | 12887 | } | |
| 1908 | |||
| 1909 | 1053226 | bool Item_typecast_unsigned::resolve_type(THD *thd) { | |
| 1910 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1053225 times.
|
1053226 | if (reject_geometry_args(arg_count, args, this)) return true; |
| 1911 | 1053225 | return args[0]->propagate_type(thd, MYSQL_TYPE_LONGLONG, false, true); | |
| 1912 | } | ||
| 1913 | |||
| 1914 | 773766 | longlong Item_typecast_unsigned::val_int() { | |
| 1915 | 773766 | longlong value = 0; | |
| 1916 | |||
| 1917 |
3/4✓ Branch 0 taken 773766 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1000 times.
✓ Branch 3 taken 772766 times.
|
773766 | if (args[0]->cast_to_int_type() == DECIMAL_RESULT) { |
| 1918 |
1/2✓ Branch 0 taken 1000 times.
✗ Branch 1 not taken.
|
1000 | my_decimal tmp, *dec = args[0]->val_decimal(&tmp); |
| 1919 | 1000 | null_value = args[0]->null_value; | |
| 1920 |
2/2✓ Branch 0 taken 993 times.
✓ Branch 1 taken 7 times.
|
1000 | if (!null_value) { |
| 1921 |
1/2✓ Branch 0 taken 993 times.
✗ Branch 1 not taken.
|
993 | my_decimal2int(E_DEC_FATAL_ERROR, dec, !dec->sign(), &value); |
| 1922 | } | ||
| 1923 |
7/8✓ Branch 0 taken 772766 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 667685 times.
✓ Branch 3 taken 105081 times.
✓ Branch 4 taken 667400 times.
✓ Branch 5 taken 285 times.
✓ Branch 6 taken 772481 times.
✓ Branch 7 taken 285 times.
|
1441451 | } else if (args[0]->cast_to_int_type() != STRING_RESULT || |
| 1924 | 667685 | args[0]->is_temporal()) { | |
| 1925 |
1/2✓ Branch 0 taken 772481 times.
✗ Branch 1 not taken.
|
772481 | value = args[0]->val_int(); |
| 1926 | 772481 | null_value = args[0]->null_value; | |
| 1927 | } else { | ||
| 1928 |
1/2✓ Branch 0 taken 285 times.
✗ Branch 1 not taken.
|
285 | value = val_int_from_str(args[0], unsigned_flag, &null_value); |
| 1929 | } | ||
| 1930 | |||
| 1931 |
3/4✓ Branch 0 taken 566848 times.
✓ Branch 1 taken 206918 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 566848 times.
|
773766 | assert(!null_value || is_nullable()); |
| 1932 |
3/6✓ Branch 0 taken 773766 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 773766 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 773766 times.
|
773766 | assert(count_digits(static_cast<ulonglong>(value)) <= decimal_int_part()); |
| 1933 | |||
| 1934 | 773766 | return value; | |
| 1935 | } | ||
| 1936 | |||
| 1937 | 500 | String *Item_typecast_decimal::val_str(String *str) { | |
| 1938 |
1/2✓ Branch 0 taken 500 times.
✗ Branch 1 not taken.
|
500 | my_decimal tmp_buf, *tmp = val_decimal(&tmp_buf); |
| 1939 |
2/2✓ Branch 0 taken 62 times.
✓ Branch 1 taken 438 times.
|
500 | if (null_value) return nullptr; |
| 1940 |
1/2✓ Branch 0 taken 438 times.
✗ Branch 1 not taken.
|
438 | my_decimal2string(E_DEC_FATAL_ERROR, tmp, str); |
| 1941 | 438 | return str; | |
| 1942 | 500 | } | |
| 1943 | |||
| 1944 | 6 | double Item_typecast_decimal::val_real() { | |
| 1945 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | my_decimal tmp_buf, *tmp = val_decimal(&tmp_buf); |
| 1946 | double res; | ||
| 1947 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4 times.
|
6 | if (null_value) return 0.0; |
| 1948 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | my_decimal2double(E_DEC_FATAL_ERROR, tmp, &res); |
| 1949 | 4 | return res; | |
| 1950 | 6 | } | |
| 1951 | |||
| 1952 | 14 | longlong Item_typecast_decimal::val_int() { | |
| 1953 |
1/2✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
|
14 | my_decimal tmp_buf, *tmp = val_decimal(&tmp_buf); |
| 1954 | longlong res; | ||
| 1955 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 12 times.
|
14 | if (null_value) return 0; |
| 1956 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | my_decimal2int(E_DEC_FATAL_ERROR, tmp, unsigned_flag, &res); |
| 1957 | 12 | return res; | |
| 1958 | 14 | } | |
| 1959 | |||
| 1960 | 11374 | my_decimal *Item_typecast_decimal::val_decimal(my_decimal *dec) { | |
| 1961 |
1/2✓ Branch 0 taken 11374 times.
✗ Branch 1 not taken.
|
11374 | my_decimal tmp_buf, *tmp = args[0]->val_decimal(&tmp_buf); |
| 1962 | bool sign; | ||
| 1963 | uint precision; | ||
| 1964 | |||
| 1965 |
2/2✓ Branch 0 taken 267 times.
✓ Branch 1 taken 11107 times.
|
11374 | if ((null_value = args[0]->null_value)) return nullptr; |
| 1966 |
1/2✓ Branch 0 taken 11107 times.
✗ Branch 1 not taken.
|
11107 | my_decimal_round(E_DEC_FATAL_ERROR, tmp, decimals, false, dec); |
| 1967 | 11107 | sign = dec->sign(); | |
| 1968 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11107 times.
|
11107 | if (unsigned_flag) { |
| 1969 | ✗ | if (sign) { | |
| 1970 | ✗ | my_decimal_set_zero(dec); | |
| 1971 | ✗ | goto err; | |
| 1972 | } | ||
| 1973 | } | ||
| 1974 | precision = | ||
| 1975 | 11107 | my_decimal_length_to_precision(max_length, decimals, unsigned_flag); | |
| 1976 |
3/4✓ Branch 0 taken 11107 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 11074 times.
|
11107 | if (precision - decimals < (uint)my_decimal_intg(dec)) { |
| 1977 |
1/2✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
|
33 | max_my_decimal(dec, precision, decimals); |
| 1978 | 33 | dec->sign(sign); | |
| 1979 | 33 | goto err; | |
| 1980 | } | ||
| 1981 | 11074 | return dec; | |
| 1982 | |||
| 1983 | 33 | err: | |
| 1984 | 33 | push_warning_printf( | |
| 1985 |
2/4✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
|
33 | current_thd, Sql_condition::SL_WARNING, ER_WARN_DATA_OUT_OF_RANGE, |
| 1986 |
2/4✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
|
33 | ER_THD(current_thd, ER_WARN_DATA_OUT_OF_RANGE), item_name.ptr(), 1L); |
| 1987 | 33 | return dec; | |
| 1988 | 11374 | } | |
| 1989 | |||
| 1990 | 121 | void Item_typecast_decimal::print(const THD *thd, String *str, | |
| 1991 | enum_query_type query_type) const { | ||
| 1992 | uint precision = | ||
| 1993 | 121 | my_decimal_length_to_precision(max_length, decimals, unsigned_flag); | |
| 1994 | 121 | str->append(STRING_WITH_LEN("cast(")); | |
| 1995 | 121 | args[0]->print(thd, str, query_type); | |
| 1996 | 121 | str->append(STRING_WITH_LEN(" as decimal(")); | |
| 1997 | 121 | str->append_ulonglong(precision); | |
| 1998 | 121 | str->append(','); | |
| 1999 | 121 | str->append_ulonglong(decimals); | |
| 2000 | 121 | str->append(')'); | |
| 2001 | 121 | str->append(')'); | |
| 2002 | 121 | } | |
| 2003 | |||
| 2004 | 1 | String *Item_typecast_real::val_str(String *str) { | |
| 2005 | 1 | double res = val_real(); | |
| 2006 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (null_value) return nullptr; |
| 2007 | |||
| 2008 | 1 | str->set_real(res, decimals, collation.collation); | |
| 2009 | 1 | return str; | |
| 2010 | } | ||
| 2011 | |||
| 2012 | 125523 | double Item_typecast_real::val_real() { | |
| 2013 | 125523 | double res = args[0]->val_real(); | |
| 2014 | 125523 | null_value = args[0]->null_value; | |
| 2015 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 125501 times.
|
125523 | if (null_value) return 0.0; |
| 2016 |
4/4✓ Branch 0 taken 235 times.
✓ Branch 1 taken 125266 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 125499 times.
|
125736 | if (data_type() == MYSQL_TYPE_FLOAT && |
| 2017 |
2/2✓ Branch 0 taken 234 times.
✓ Branch 1 taken 1 times.
|
235 | ((res > std::numeric_limits<float>::max()) || |
| 2018 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 233 times.
|
234 | res < std::numeric_limits<float>::lowest())) |
| 2019 | 2 | return raise_float_overflow(); | |
| 2020 | 125499 | return check_float_overflow(res); | |
| 2021 | } | ||
| 2022 | |||
| 2023 | 1 | longlong Item_func::val_int_from_real() { | |
| 2024 | 1 | double res = val_real(); | |
| 2025 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (null_value) return 0; |
| 2026 | |||
| 2027 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (unsigned_flag) { |
| 2028 | ✗ | if (res < 0 || res >= ULLONG_MAX_DOUBLE) { | |
| 2029 | ✗ | return raise_integer_overflow(); | |
| 2030 | } else | ||
| 2031 | ✗ | return (longlong)double2ulonglong(res); | |
| 2032 | } else { | ||
| 2033 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | if (res <= LLONG_MIN || res > LLONG_MAX_DOUBLE) { |
| 2034 | 1 | return raise_integer_overflow(); | |
| 2035 | } else | ||
| 2036 | ✗ | return (longlong)res; | |
| 2037 | } | ||
| 2038 | } | ||
| 2039 | |||
| 2040 | 1 | bool Item_typecast_real::get_date(MYSQL_TIME *ltime, | |
| 2041 | my_time_flags_t fuzzydate) { | ||
| 2042 | 1 | return my_double_to_datetime_with_warn(val_real(), ltime, fuzzydate); | |
| 2043 | } | ||
| 2044 | |||
| 2045 | 1 | bool Item_typecast_real::get_time(MYSQL_TIME *ltime) { | |
| 2046 | 1 | return my_double_to_time_with_warn(val_real(), ltime); | |
| 2047 | } | ||
| 2048 | |||
| 2049 | 2 | my_decimal *Item_typecast_real::val_decimal(my_decimal *decimal_value) { | |
| 2050 | 2 | double result = val_real(); | |
| 2051 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (null_value) return nullptr; |
| 2052 | 2 | double2my_decimal(E_DEC_FATAL_ERROR, result, decimal_value); | |
| 2053 | |||
| 2054 | 2 | return decimal_value; | |
| 2055 | } | ||
| 2056 | |||
| 2057 | 921 | void Item_typecast_real::print(const THD *thd, String *str, | |
| 2058 | enum_query_type query_type) const { | ||
| 2059 | 921 | str->append(STRING_WITH_LEN("cast(")); | |
| 2060 | 921 | args[0]->print(thd, str, query_type); | |
| 2061 | 921 | str->append(STRING_WITH_LEN(" as ")); | |
| 2062 |
3/4✓ Branch 0 taken 6 times.
✓ Branch 1 taken 915 times.
✓ Branch 2 taken 921 times.
✗ Branch 3 not taken.
|
921 | str->append((data_type() == MYSQL_TYPE_FLOAT) ? "float)" : "double)"); |
| 2063 | 921 | } | |
| 2064 | |||
| 2065 | 921199 | double Item_func_plus::real_op() { | |
| 2066 | 921199 | double val1 = args[0]->val_real(); | |
| 2067 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 921199 times.
|
921201 | if (current_thd->is_error()) return error_real(); |
| 2068 | 921199 | double val2 = args[1]->val_real(); | |
| 2069 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 921196 times.
|
921200 | if (current_thd->is_error()) return error_real(); |
| 2070 | |||
| 2071 |
6/6✓ Branch 0 taken 921138 times.
✓ Branch 1 taken 58 times.
✓ Branch 2 taken 34 times.
✓ Branch 3 taken 921104 times.
✓ Branch 4 taken 92 times.
✓ Branch 5 taken 921104 times.
|
921196 | if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0; |
| 2072 | 921104 | double value = val1 + val2; | |
| 2073 | 921104 | return check_float_overflow(value); | |
| 2074 | } | ||
| 2075 | |||
| 2076 | 67766357 | longlong Item_func_plus::int_op() { | |
| 2077 | 67766357 | longlong val0 = args[0]->val_int(); | |
| 2078 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 67767102 times.
|
67767312 | if (current_thd->is_error()) return error_int(); |
| 2079 | 67767102 | longlong val1 = args[1]->val_int(); | |
| 2080 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 67767148 times.
|
67766885 | if (current_thd->is_error()) return error_int(); |
| 2081 | 67767148 | longlong res = static_cast<unsigned long long>(val0) + | |
| 2082 | 67767148 | static_cast<unsigned long long>(val1); | |
| 2083 | 67767148 | bool res_unsigned = false; | |
| 2084 | |||
| 2085 |
6/6✓ Branch 0 taken 67759796 times.
✓ Branch 1 taken 7352 times.
✓ Branch 2 taken 479 times.
✓ Branch 3 taken 67759317 times.
✓ Branch 4 taken 7831 times.
✓ Branch 5 taken 67759317 times.
|
67767148 | if ((null_value = args[0]->null_value || args[1]->null_value)) return 0; |
| 2086 | |||
| 2087 | /* | ||
| 2088 | First check whether the result can be represented as a | ||
| 2089 | (bool unsigned_flag, longlong value) pair, then check if it is compatible | ||
| 2090 | with this Item's unsigned_flag by calling check_integer_overflow(). | ||
| 2091 | */ | ||
| 2092 |
2/2✓ Branch 0 taken 484163 times.
✓ Branch 1 taken 67275154 times.
|
67759317 | if (args[0]->unsigned_flag) { |
| 2093 |
4/4✓ Branch 0 taken 103114 times.
✓ Branch 1 taken 381049 times.
✓ Branch 2 taken 103113 times.
✓ Branch 3 taken 1 times.
|
484163 | if (args[1]->unsigned_flag || val1 >= 0) { |
| 2094 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 484135 times.
|
484162 | if (test_if_sum_overflows_ull((ulonglong)val0, (ulonglong)val1)) goto err; |
| 2095 | 484135 | res_unsigned = true; | |
| 2096 | } else { | ||
| 2097 | /* val1 is negative */ | ||
| 2098 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if ((ulonglong)val0 > (ulonglong)LLONG_MAX) res_unsigned = true; |
| 2099 | } | ||
| 2100 | } else { | ||
| 2101 |
2/2✓ Branch 0 taken 25493 times.
✓ Branch 1 taken 67249661 times.
|
67275154 | if (args[1]->unsigned_flag) { |
| 2102 |
2/2✓ Branch 0 taken 25491 times.
✓ Branch 1 taken 2 times.
|
25493 | if (val0 >= 0) { |
| 2103 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 25490 times.
|
25491 | if (test_if_sum_overflows_ull((ulonglong)val0, (ulonglong)val1)) |
| 2104 | 1 | goto err; | |
| 2105 | 25490 | res_unsigned = true; | |
| 2106 | } else { | ||
| 2107 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | if ((ulonglong)val1 > (ulonglong)LLONG_MAX) res_unsigned = true; |
| 2108 | } | ||
| 2109 | } else { | ||
| 2110 |
4/4✓ Branch 0 taken 67217303 times.
✓ Branch 1 taken 32358 times.
✓ Branch 2 taken 67202943 times.
✓ Branch 3 taken 14360 times.
|
67249661 | if (val0 >= 0 && val1 >= 0) |
| 2111 | 67202943 | res_unsigned = true; | |
| 2112 |
6/6✓ Branch 0 taken 31995 times.
✓ Branch 1 taken 14723 times.
✓ Branch 2 taken 11729 times.
✓ Branch 3 taken 20266 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 11728 times.
|
46718 | else if (val0 < 0 && val1 < 0 && res >= 0) |
| 2113 | 1 | goto err; | |
| 2114 | } | ||
| 2115 | } | ||
| 2116 | 67759288 | return check_integer_overflow(res, res_unsigned); | |
| 2117 | |||
| 2118 | 29 | err: | |
| 2119 | 29 | return raise_integer_overflow(); | |
| 2120 | } | ||
| 2121 | |||
| 2122 | /** | ||
| 2123 | Calculate plus of two decimals. | ||
| 2124 | |||
| 2125 | @param decimal_value Buffer that can be used to store result | ||
| 2126 | |||
| 2127 | @return Value of operation as a decimal | ||
| 2128 | @retval | ||
| 2129 | 0 Value was NULL; In this case null_value is set | ||
| 2130 | */ | ||
| 2131 | |||
| 2132 | 319733 | my_decimal *Item_func_plus::decimal_op(my_decimal *decimal_value) { | |
| 2133 | 319733 | my_decimal value1, *val1; | |
| 2134 | 319745 | my_decimal value2, *val2; | |
| 2135 |
1/2✓ Branch 0 taken 319736 times.
✗ Branch 1 not taken.
|
319745 | val1 = args[0]->val_decimal(&value1); |
| 2136 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 319726 times.
|
319736 | if ((null_value = args[0]->null_value)) return nullptr; |
| 2137 |
1/2✓ Branch 0 taken 319727 times.
✗ Branch 1 not taken.
|
319726 | val2 = args[1]->val_decimal(&value2); |
| 2138 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 319706 times.
|
319727 | if ((null_value = args[1]->null_value)) return nullptr; |
| 2139 | |||
| 2140 |
2/4✓ Branch 0 taken 319717 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 319714 times.
✗ Branch 3 not taken.
|
319706 | if (check_decimal_overflow(my_decimal_add(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, |
| 2141 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 319714 times.
|
319714 | decimal_value, val1, val2)) > 3) { |
| 2142 | ✗ | return error_decimal(decimal_value); | |
| 2143 | } | ||
| 2144 | 319714 | return decimal_value; | |
| 2145 | 319745 | } | |
| 2146 | |||
| 2147 | /** | ||
| 2148 | Set precision of results for additive operations (+ and -) | ||
| 2149 | */ | ||
| 2150 | 1863745 | void Item_func_additive_op::result_precision() { | |
| 2151 | 1863745 | decimals = max(args[0]->decimals, args[1]->decimals); | |
| 2152 |
1/2✓ Branch 0 taken 1863737 times.
✗ Branch 1 not taken.
|
1863752 | int arg1_int = args[0]->decimal_precision() - args[0]->decimals; |
| 2153 |
1/2✓ Branch 0 taken 1863747 times.
✗ Branch 1 not taken.
|
1863737 | int arg2_int = args[1]->decimal_precision() - args[1]->decimals; |
| 2154 | 1863747 | int precision = max(arg1_int, arg2_int) + 1 + decimals; | |
| 2155 | |||
| 2156 | /* Integer operations keep unsigned_flag if one of arguments is unsigned */ | ||
| 2157 |
3/4✓ Branch 0 taken 1863745 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1824652 times.
✓ Branch 3 taken 39093 times.
|
1863747 | if (result_type() == INT_RESULT) |
| 2158 | 1824652 | unsigned_flag = args[0]->unsigned_flag | args[1]->unsigned_flag; | |
| 2159 | else | ||
| 2160 | 39093 | unsigned_flag = args[0]->unsigned_flag & args[1]->unsigned_flag; | |
| 2161 | 3727495 | max_length = my_decimal_precision_to_length_no_truncation(precision, decimals, | |
| 2162 | 1863745 | unsigned_flag); | |
| 2163 | 1863750 | } | |
| 2164 | |||
| 2165 | /** | ||
| 2166 | The following function is here to allow the user to force | ||
| 2167 | subtraction of UNSIGNED BIGINT/DECIMAL to return negative values. | ||
| 2168 | */ | ||
| 2169 | |||
| 2170 | 892027 | bool Item_func_minus::resolve_type(THD *thd) { | |
| 2171 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 892025 times.
|
892027 | if (Item_num_op::resolve_type(thd)) return true; |
| 2172 |
4/4✓ Branch 0 taken 63332 times.
✓ Branch 1 taken 828693 times.
✓ Branch 2 taken 29 times.
✓ Branch 3 taken 63303 times.
|
892025 | if (unsigned_flag && (thd->variables.sql_mode & MODE_NO_UNSIGNED_SUBTRACTION)) |
| 2173 | 29 | unsigned_flag = false; | |
| 2174 | 892025 | return false; | |
| 2175 | } | ||
| 2176 | |||
| 2177 | 3679 | double Item_func_minus::real_op() { | |
| 2178 | 3679 | double val1 = args[0]->val_real(); | |
| 2179 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3678 times.
|
3679 | if (current_thd->is_error()) return error_real(); |
| 2180 | 3678 | double val2 = args[1]->val_real(); | |
| 2181 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3678 times.
|
3678 | if (current_thd->is_error()) return error_real(); |
| 2182 | |||
| 2183 |
6/6✓ Branch 0 taken 3677 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 3676 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 3676 times.
|
3678 | if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0; |
| 2184 | 3676 | double value = val1 - val2; | |
| 2185 | 3676 | return check_float_overflow(value); | |
| 2186 | } | ||
| 2187 | |||
| 2188 | 2423816 | longlong Item_func_minus::int_op() { | |
| 2189 | 2423816 | longlong val0 = args[0]->val_int(); | |
| 2190 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2423814 times.
|
2423816 | if (current_thd->is_error()) return error_int(); |
| 2191 | 2423814 | longlong val1 = args[1]->val_int(); | |
| 2192 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2423812 times.
|
2423814 | if (current_thd->is_error()) return error_int(); |
| 2193 | 2423812 | longlong res = static_cast<unsigned long long>(val0) - | |
| 2194 | 2423812 | static_cast<unsigned long long>(val1); | |
| 2195 | 2423812 | bool res_unsigned = false; | |
| 2196 | |||
| 2197 |
6/6✓ Branch 0 taken 2423748 times.
✓ Branch 1 taken 64 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 2423739 times.
✓ Branch 4 taken 73 times.
✓ Branch 5 taken 2423739 times.
|
2423812 | if ((null_value = args[0]->null_value || args[1]->null_value)) return 0; |
| 2198 | |||
| 2199 | /* | ||
| 2200 | First check whether the result can be represented as a | ||
| 2201 | (bool unsigned_flag, longlong value) pair, then check if it is compatible | ||
| 2202 | with this Item's unsigned_flag by calling check_integer_overflow(). | ||
| 2203 | */ | ||
| 2204 |
2/2✓ Branch 0 taken 665307 times.
✓ Branch 1 taken 1758432 times.
|
2423739 | if (args[0]->unsigned_flag) { |
| 2205 |
2/2✓ Branch 0 taken 1260 times.
✓ Branch 1 taken 664047 times.
|
665307 | if (args[1]->unsigned_flag) { |
| 2206 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1256 times.
|
1260 | if ((ulonglong)val0 < (ulonglong)val1) { |
| 2207 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
|
4 | if (res >= 0) goto err; |
| 2208 | } else | ||
| 2209 | 1256 | res_unsigned = true; | |
| 2210 | } else { | ||
| 2211 |
2/2✓ Branch 0 taken 664045 times.
✓ Branch 1 taken 2 times.
|
664047 | if (val1 >= 0) { |
| 2212 |
2/2✓ Branch 0 taken 643869 times.
✓ Branch 1 taken 20176 times.
|
664045 | if ((ulonglong)val0 > (ulonglong)val1) res_unsigned = true; |
| 2213 | } else { | ||
| 2214 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | if (test_if_sum_overflows_ull((ulonglong)val0, (ulonglong)-val1)) |
| 2215 | 1 | goto err; | |
| 2216 | 1 | res_unsigned = true; | |
| 2217 | } | ||
| 2218 | } | ||
| 2219 | } else { | ||
| 2220 |
2/2✓ Branch 0 taken 1023 times.
✓ Branch 1 taken 1757409 times.
|
1758432 | if (args[1]->unsigned_flag) { |
| 2221 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1022 times.
|
1023 | if ((ulonglong)(val0 - LLONG_MIN) < (ulonglong)val1) goto err; |
| 2222 | } else { | ||
| 2223 |
4/4✓ Branch 0 taken 1738261 times.
✓ Branch 1 taken 19148 times.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 1738254 times.
|
1757409 | if (val0 >= 0 && val1 < 0) |
| 2224 | 7 | res_unsigned = true; | |
| 2225 |
5/6✓ Branch 0 taken 19148 times.
✓ Branch 1 taken 1738254 times.
✓ Branch 2 taken 19148 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 19147 times.
|
1757402 | else if (val0 < 0 && val1 > 0 && res >= 0) |
| 2226 | 1 | goto err; | |
| 2227 | } | ||
| 2228 | } | ||
| 2229 | 2423735 | return check_integer_overflow(res, res_unsigned); | |
| 2230 | |||
| 2231 | 4 | err: | |
| 2232 | 4 | return raise_integer_overflow(); | |
| 2233 | } | ||
| 2234 | |||
| 2235 | /** | ||
| 2236 | See Item_func_plus::decimal_op for comments. | ||
| 2237 | */ | ||
| 2238 | |||
| 2239 | 205992 | my_decimal *Item_func_minus::decimal_op(my_decimal *decimal_value) { | |
| 2240 | 205992 | my_decimal value1, *val1; | |
| 2241 | 205992 | my_decimal value2, *val2; | |
| 2242 | |||
| 2243 |
1/2✓ Branch 0 taken 205992 times.
✗ Branch 1 not taken.
|
205992 | val1 = args[0]->val_decimal(&value1); |
| 2244 |
2/2✓ Branch 0 taken 188 times.
✓ Branch 1 taken 205804 times.
|
205992 | if ((null_value = args[0]->null_value)) return nullptr; |
| 2245 | |||
| 2246 |
1/2✓ Branch 0 taken 205804 times.
✗ Branch 1 not taken.
|
205804 | val2 = args[1]->val_decimal(&value2); |
| 2247 |
2/2✓ Branch 0 taken 227 times.
✓ Branch 1 taken 205577 times.
|
205804 | if ((null_value = args[1]->null_value)) return nullptr; |
| 2248 | |||
| 2249 |
2/4✓ Branch 0 taken 205577 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 205577 times.
✗ Branch 3 not taken.
|
205577 | if (check_decimal_overflow(my_decimal_sub(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, |
| 2250 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 205577 times.
|
205577 | decimal_value, val1, val2)) > 3) { |
| 2251 | ✗ | return error_decimal(decimal_value); | |
| 2252 | } | ||
| 2253 | /* | ||
| 2254 | Allow sign mismatch only if sql_mode includes MODE_NO_UNSIGNED_SUBTRACTION | ||
| 2255 | See Item_func_minus::resolve_type(). | ||
| 2256 | */ | ||
| 2257 |
6/6✓ Branch 0 taken 5 times.
✓ Branch 1 taken 205572 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 205574 times.
|
205577 | if (unsigned_flag && decimal_value->sign()) { |
| 2258 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | raise_decimal_overflow(); |
| 2259 | 3 | return error_decimal(decimal_value); | |
| 2260 | } | ||
| 2261 | 205574 | return decimal_value; | |
| 2262 | 205992 | } | |
| 2263 | |||
| 2264 | 3969358 | double Item_func_mul::real_op() { | |
| 2265 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3969358 times.
|
3969358 | assert(fixed == 1); |
| 2266 | 3969358 | double val1 = args[0]->val_real(); | |
| 2267 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3969358 times.
|
3969359 | if (current_thd->is_error()) return error_real(); |
| 2268 | 3969358 | double val2 = args[1]->val_real(); | |
| 2269 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3969359 times.
|
3969359 | if (current_thd->is_error()) return error_real(); |
| 2270 | |||
| 2271 |
6/6✓ Branch 0 taken 3969358 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 3969357 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 3969357 times.
|
3969359 | if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0; |
| 2272 | 3969357 | double value = val1 * val2; | |
| 2273 | 3969357 | return check_float_overflow(value); | |
| 2274 | } | ||
| 2275 | |||
| 2276 | 5938460 | longlong Item_func_mul::int_op() { | |
| 2277 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5938460 times.
|
5938460 | assert(fixed == 1); |
| 2278 | 5938460 | longlong a = args[0]->val_int(); | |
| 2279 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5938475 times.
|
5938481 | if (current_thd->is_error()) return error_int(); |
| 2280 | 5938475 | longlong b = args[1]->val_int(); | |
| 2281 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 5938471 times.
|
5938478 | if (current_thd->is_error()) return error_int(); |
| 2282 | longlong res; | ||
| 2283 | ulonglong res0, res1; | ||
| 2284 | |||
| 2285 |
6/6✓ Branch 0 taken 5938338 times.
✓ Branch 1 taken 133 times.
✓ Branch 2 taken 79 times.
✓ Branch 3 taken 5938259 times.
✓ Branch 4 taken 212 times.
✓ Branch 5 taken 5938259 times.
|
5938471 | if ((null_value = args[0]->null_value || args[1]->null_value)) return 0; |
| 2286 | |||
| 2287 |
4/4✓ Branch 0 taken 5821763 times.
✓ Branch 1 taken 116496 times.
✓ Branch 2 taken 448224 times.
✓ Branch 3 taken 5373539 times.
|
5938259 | if (a == 0 || b == 0) return 0; |
| 2288 | |||
| 2289 | /* | ||
| 2290 | First check whether the result can be represented as a | ||
| 2291 | (bool unsigned_flag, longlong value) pair, then check if it is compatible | ||
| 2292 | with this Item's unsigned_flag by calling check_integer_overflow(). | ||
| 2293 | |||
| 2294 | Let a = a1 * 2^32 + a0 and b = b1 * 2^32 + b0. Then | ||
| 2295 | a * b = (a1 * 2^32 + a0) * (b1 * 2^32 + b0) = a1 * b1 * 2^64 + | ||
| 2296 | + (a1 * b0 + a0 * b1) * 2^32 + a0 * b0; | ||
| 2297 | We can determine if the above sum overflows the ulonglong range by | ||
| 2298 | sequentially checking the following conditions: | ||
| 2299 | 1. If both a1 and b1 are non-zero. | ||
| 2300 | 2. Otherwise, if (a1 * b0 + a0 * b1) is greater than ULONG_MAX. | ||
| 2301 | 3. Otherwise, if (a1 * b0 + a0 * b1) * 2^32 + a0 * b0 is greater than | ||
| 2302 | ULLONG_MAX. | ||
| 2303 | |||
| 2304 | Since we also have to take the unsigned_flag for a and b into account, | ||
| 2305 | it is easier to first work with absolute values and set the | ||
| 2306 | correct sign later. | ||
| 2307 | |||
| 2308 | We handle INT_MIN64 == -9223372036854775808 specially first, | ||
| 2309 | to avoid UBSAN warnings. | ||
| 2310 | */ | ||
| 2311 |
4/4✓ Branch 0 taken 5073155 times.
✓ Branch 1 taken 300384 times.
✓ Branch 2 taken 851 times.
✓ Branch 3 taken 5072304 times.
|
5373539 | const bool a_negative = (!args[0]->unsigned_flag && a < 0); |
| 2312 |
4/4✓ Branch 0 taken 5363995 times.
✓ Branch 1 taken 9544 times.
✓ Branch 2 taken 652 times.
✓ Branch 3 taken 5363343 times.
|
5373539 | const bool b_negative = (!args[1]->unsigned_flag && b < 0); |
| 2313 | |||
| 2314 | 5373539 | const bool res_unsigned = (a_negative == b_negative); | |
| 2315 | |||
| 2316 |
4/4✓ Branch 0 taken 851 times.
✓ Branch 1 taken 5372688 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 847 times.
|
5373539 | if (a_negative && a == INT_MIN64) { |
| 2317 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
|
4 | if (b == 1) return check_integer_overflow(a, res_unsigned); |
| 2318 | 3 | return raise_integer_overflow(); | |
| 2319 | } | ||
| 2320 | |||
| 2321 |
4/4✓ Branch 0 taken 651 times.
✓ Branch 1 taken 5372884 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 647 times.
|
5373535 | if (b_negative && b == INT_MIN64) { |
| 2322 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
|
4 | if (a == 1) return check_integer_overflow(b, res_unsigned); |
| 2323 | 3 | return raise_integer_overflow(); | |
| 2324 | } | ||
| 2325 | |||
| 2326 |
2/2✓ Branch 0 taken 846 times.
✓ Branch 1 taken 5372685 times.
|
5373531 | if (a_negative) { |
| 2327 | 846 | a = -a; | |
| 2328 | } | ||
| 2329 |
2/2✓ Branch 0 taken 647 times.
✓ Branch 1 taken 5372884 times.
|
5373531 | if (b_negative) { |
| 2330 | 647 | b = -b; | |
| 2331 | } | ||
| 2332 | |||
| 2333 | 5373531 | ulong a0 = 0xFFFFFFFFUL & a; | |
| 2334 | 5373531 | ulong a1 = ((ulonglong)a) >> 32; | |
| 2335 | 5373531 | ulong b0 = 0xFFFFFFFFUL & b; | |
| 2336 | 5373531 | ulong b1 = ((ulonglong)b) >> 32; | |
| 2337 | |||
| 2338 |
4/4✓ Branch 0 taken 157 times.
✓ Branch 1 taken 5373374 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 156 times.
|
5373531 | if (a1 && b1) goto err; |
| 2339 | |||
| 2340 | 5373530 | res1 = (ulonglong)a1 * b0 + (ulonglong)a0 * b1; | |
| 2341 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 5373523 times.
|
5373530 | if (res1 > 0xFFFFFFFFUL) goto err; |
| 2342 | |||
| 2343 | 5373523 | res1 = res1 << 32; | |
| 2344 | 5373523 | res0 = (ulonglong)a0 * b0; | |
| 2345 | |||
| 2346 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5373503 times.
|
5373523 | if (test_if_sum_overflows_ull(res1, res0)) goto err; |
| 2347 | 5373503 | res = res1 + res0; | |
| 2348 | |||
| 2349 |
2/2✓ Branch 0 taken 1333 times.
✓ Branch 1 taken 5372170 times.
|
5373503 | if (a_negative != b_negative) { |
| 2350 |
2/2✓ Branch 0 taken 85 times.
✓ Branch 1 taken 1248 times.
|
1333 | if ((ulonglong)res > (ulonglong)LLONG_MAX) goto err; |
| 2351 | 1248 | res = -res; | |
| 2352 | } | ||
| 2353 | |||
| 2354 | 5373418 | return check_integer_overflow(res, res_unsigned); | |
| 2355 | |||
| 2356 | 94 | err: | |
| 2357 | 94 | return raise_integer_overflow(); | |
| 2358 | } | ||
| 2359 | |||
| 2360 | /** See Item_func_plus::decimal_op for comments. */ | ||
| 2361 | |||
| 2362 | 385735 | my_decimal *Item_func_mul::decimal_op(my_decimal *decimal_value) { | |
| 2363 | 385735 | my_decimal value1, *val1; | |
| 2364 | 385735 | my_decimal value2, *val2; | |
| 2365 |
1/2✓ Branch 0 taken 385735 times.
✗ Branch 1 not taken.
|
385735 | val1 = args[0]->val_decimal(&value1); |
| 2366 |
2/2✓ Branch 0 taken 253 times.
✓ Branch 1 taken 385482 times.
|
385735 | if ((null_value = args[0]->null_value)) return nullptr; |
| 2367 |
1/2✓ Branch 0 taken 385482 times.
✗ Branch 1 not taken.
|
385482 | val2 = args[1]->val_decimal(&value2); |
| 2368 |
2/2✓ Branch 0 taken 123 times.
✓ Branch 1 taken 385359 times.
|
385482 | if ((null_value = args[1]->null_value)) return nullptr; |
| 2369 | |||
| 2370 |
2/4✓ Branch 0 taken 385359 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 385359 times.
✗ Branch 3 not taken.
|
385359 | if (check_decimal_overflow(my_decimal_mul(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, |
| 2371 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 385359 times.
|
385359 | decimal_value, val1, val2)) > 3) { |
| 2372 | ✗ | return error_decimal(decimal_value); | |
| 2373 | } | ||
| 2374 | 385359 | return decimal_value; | |
| 2375 | 385735 | } | |
| 2376 | |||
| 2377 | 187909 | void Item_func_mul::result_precision() { | |
| 2378 | /* Integer operations keep unsigned_flag if one of arguments is unsigned */ | ||
| 2379 |
2/2✓ Branch 0 taken 168304 times.
✓ Branch 1 taken 19605 times.
|
187909 | if (result_type() == INT_RESULT) |
| 2380 | 168304 | unsigned_flag = args[0]->unsigned_flag | args[1]->unsigned_flag; | |
| 2381 | else | ||
| 2382 | 19605 | unsigned_flag = args[0]->unsigned_flag & args[1]->unsigned_flag; | |
| 2383 | 187909 | decimals = min(args[0]->decimals + args[1]->decimals, DECIMAL_MAX_SCALE); | |
| 2384 |
2/4✓ Branch 0 taken 187909 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 187909 times.
✗ Branch 3 not taken.
|
187910 | uint est_prec = args[0]->decimal_precision() + args[1]->decimal_precision(); |
| 2385 | 187909 | uint precision = min<uint>(est_prec, DECIMAL_MAX_PRECISION); | |
| 2386 | 375818 | max_length = my_decimal_precision_to_length_no_truncation(precision, decimals, | |
| 2387 | 187909 | unsigned_flag); | |
| 2388 | 187909 | } | |
| 2389 | |||
| 2390 | 6502 | double Item_func_div_base::real_op() { | |
| 2391 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6502 times.
|
6502 | assert(fixed); |
| 2392 | 6502 | double val1 = args[0]->val_real(); | |
| 2393 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6501 times.
|
6502 | if (current_thd->is_error()) return error_real(); |
| 2394 | 6501 | double val2 = args[1]->val_real(); | |
| 2395 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6501 times.
|
6501 | if (current_thd->is_error()) return error_real(); |
| 2396 | |||
| 2397 |
5/6✓ Branch 0 taken 6501 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 6488 times.
✓ Branch 4 taken 13 times.
✓ Branch 5 taken 6488 times.
|
6501 | if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0; |
| 2398 |
2/2✓ Branch 0 taken 5043 times.
✓ Branch 1 taken 1445 times.
|
6488 | if (val2 == 0.0) { |
| 2399 | 5043 | signal_divide_by_null(); | |
| 2400 | 5043 | return 0.0; | |
| 2401 | } | ||
| 2402 | 1445 | return check_float_overflow(val1 / val2); | |
| 2403 | } | ||
| 2404 | |||
| 2405 | 1114362 | my_decimal *Item_func_div_base::decimal_op(my_decimal *decimal_value) { | |
| 2406 | 1114362 | my_decimal value1, *val1; | |
| 2407 | 1114362 | my_decimal value2, *val2; | |
| 2408 | int err; | ||
| 2409 | |||
| 2410 |
1/2✓ Branch 0 taken 1114362 times.
✗ Branch 1 not taken.
|
1114362 | val1 = args[0]->val_decimal(&value1); |
| 2411 |
2/2✓ Branch 0 taken 5465 times.
✓ Branch 1 taken 1108897 times.
|
1114362 | if ((null_value = args[0]->null_value)) return nullptr; |
| 2412 |
1/2✓ Branch 0 taken 1108897 times.
✗ Branch 1 not taken.
|
1108897 | val2 = args[1]->val_decimal(&value2); |
| 2413 |
2/2✓ Branch 0 taken 1002 times.
✓ Branch 1 taken 1107895 times.
|
1108897 | if ((null_value = args[1]->null_value)) return nullptr; |
| 2414 | |||
| 2415 |
1/2✓ Branch 0 taken 1107895 times.
✗ Branch 1 not taken.
|
1107895 | if ((err = check_decimal_overflow( |
| 2416 | my_decimal_div(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW & ~E_DEC_DIV_ZERO, | ||
| 2417 |
3/4✓ Branch 0 taken 1107895 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6138 times.
✓ Branch 3 taken 1101757 times.
|
2215790 | decimal_value, val1, val2, m_prec_increment))) > 3) { |
| 2418 |
2/4✓ Branch 0 taken 6138 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6138 times.
✗ Branch 3 not taken.
|
6138 | if (err == E_DEC_DIV_ZERO) signal_divide_by_null(); |
| 2419 | 6138 | return error_decimal(decimal_value); | |
| 2420 | } | ||
| 2421 | 1101757 | return decimal_value; | |
| 2422 | 1114362 | } | |
| 2423 | |||
| 2424 | 580230 | void Item_func_div::result_precision() { | |
| 2425 | 580230 | uint precision = min<uint>( | |
| 2426 | 580230 | args[0]->decimal_precision() + args[1]->decimals + m_prec_increment, | |
| 2427 |
1/2✓ Branch 0 taken 580230 times.
✗ Branch 1 not taken.
|
580230 | DECIMAL_MAX_PRECISION); |
| 2428 | |||
| 2429 |
3/4✓ Branch 0 taken 362477 times.
✓ Branch 1 taken 217753 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 362477 times.
|
580230 | if (result_type() == DECIMAL_RESULT) assert(precision > 0); |
| 2430 | |||
| 2431 | /* Integer operations keep unsigned_flag if one of arguments is unsigned */ | ||
| 2432 |
2/2✓ Branch 0 taken 217753 times.
✓ Branch 1 taken 362477 times.
|
580230 | if (result_type() == INT_RESULT) |
| 2433 | 217753 | unsigned_flag = args[0]->unsigned_flag | args[1]->unsigned_flag; | |
| 2434 | else | ||
| 2435 | 362477 | unsigned_flag = args[0]->unsigned_flag & args[1]->unsigned_flag; | |
| 2436 | 580230 | decimals = min<uint>(args[0]->decimals + m_prec_increment, DECIMAL_MAX_SCALE); | |
| 2437 | 1160460 | max_length = my_decimal_precision_to_length_no_truncation(precision, decimals, | |
| 2438 | 580230 | unsigned_flag); | |
| 2439 | 580230 | } | |
| 2440 | |||
| 2441 | 36304 | void Item_func_div_int::result_precision() { | |
| 2442 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 36304 times.
|
36304 | assert(result_type() == INT_RESULT); |
| 2443 | |||
| 2444 | // Integer operations keep unsigned_flag if one of arguments is unsigned | ||
| 2445 | 36304 | unsigned_flag = args[0]->unsigned_flag | args[1]->unsigned_flag; | |
| 2446 | |||
| 2447 | 36304 | uint arg0_decimals = args[0]->decimals; | |
| 2448 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 36284 times.
|
36304 | if (arg0_decimals == DECIMAL_NOT_SPECIFIED) arg0_decimals = 0; |
| 2449 | 36304 | uint arg1_decimals = args[1]->decimals; | |
| 2450 |
2/2✓ Branch 0 taken 19 times.
✓ Branch 1 taken 36285 times.
|
36304 | if (arg1_decimals == DECIMAL_NOT_SPECIFIED) |
| 2451 | 19 | arg1_decimals = args[1]->decimal_precision(); | |
| 2452 | |||
| 2453 | uint precision = | ||
| 2454 | 36304 | min<uint>(args[0]->decimal_precision() - arg0_decimals + arg1_decimals, | |
| 2455 |
1/2✓ Branch 0 taken 36304 times.
✗ Branch 1 not taken.
|
36304 | MY_INT64_NUM_DECIMAL_DIGITS); |
| 2456 | |||
| 2457 | 36304 | max_length = | |
| 2458 | 36304 | my_decimal_precision_to_length_no_truncation(precision, 0, unsigned_flag); | |
| 2459 | 36304 | } | |
| 2460 | |||
| 2461 | 295488 | bool Item_func_div::resolve_type(THD *thd) { | |
| 2462 |
1/2✓ Branch 0 taken 295488 times.
✗ Branch 1 not taken.
|
295488 | DBUG_TRACE; |
| 2463 | 295488 | m_prec_increment = thd->variables.div_precincrement; | |
| 2464 |
3/4✓ Branch 0 taken 295488 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 295485 times.
|
295488 | if (Item_num_op::resolve_type(thd)) return true; |
| 2465 | |||
| 2466 |
3/4✓ Branch 0 taken 5370 times.
✓ Branch 1 taken 217753 times.
✓ Branch 2 taken 72362 times.
✗ Branch 3 not taken.
|
295485 | switch (hybrid_type) { |
| 2467 | 5370 | case REAL_RESULT: { | |
| 2468 | 5370 | decimals = max(args[0]->decimals, args[1]->decimals) + m_prec_increment; | |
| 2469 | 5370 | decimals = min(decimals, uint8(DECIMAL_NOT_SPECIFIED)); | |
| 2470 | 5370 | uint tmp = float_length(decimals); | |
| 2471 |
2/2✓ Branch 0 taken 5306 times.
✓ Branch 1 taken 64 times.
|
5370 | if (decimals == DECIMAL_NOT_SPECIFIED) |
| 2472 | 5306 | max_length = tmp; | |
| 2473 | else { | ||
| 2474 | 64 | max_length = args[0]->max_length - args[0]->decimals + decimals; | |
| 2475 | 64 | max_length = min(max_length, tmp); | |
| 2476 | } | ||
| 2477 | 5370 | break; | |
| 2478 | } | ||
| 2479 | 217753 | case INT_RESULT: | |
| 2480 | 217753 | set_data_type(MYSQL_TYPE_NEWDECIMAL); | |
| 2481 | 217753 | hybrid_type = DECIMAL_RESULT; | |
| 2482 |
3/8✓ Branch 0 taken 217753 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 217753 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 217753 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
217753 | DBUG_PRINT("info", ("Type changed: DECIMAL_RESULT")); |
| 2483 |
1/2✓ Branch 0 taken 217753 times.
✗ Branch 1 not taken.
|
217753 | result_precision(); |
| 2484 | 217753 | break; | |
| 2485 | 72362 | case DECIMAL_RESULT: | |
| 2486 |
1/2✓ Branch 0 taken 72362 times.
✗ Branch 1 not taken.
|
72362 | result_precision(); |
| 2487 | 72362 | break; | |
| 2488 | ✗ | default: | |
| 2489 | ✗ | assert(0); | |
| 2490 | } | ||
| 2491 | 295485 | set_nullable(true); // division by zero | |
| 2492 | 295485 | return false; | |
| 2493 | 295488 | } | |
| 2494 | |||
| 2495 | 124323 | longlong Item_func_div_base::int_op() { | |
| 2496 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 124323 times.
|
124323 | assert(fixed); |
| 2497 | |||
| 2498 | /* | ||
| 2499 | Perform division using DECIMAL math if either of the operands has a | ||
| 2500 | non-integer type | ||
| 2501 | */ | ||
| 2502 |
4/4✓ Branch 0 taken 124268 times.
✓ Branch 1 taken 55 times.
✓ Branch 2 taken 67 times.
✓ Branch 3 taken 124256 times.
|
248591 | if (args[0]->result_type() != INT_RESULT || |
| 2503 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 124256 times.
|
124268 | args[1]->result_type() != INT_RESULT) { |
| 2504 | 67 | my_decimal tmp; | |
| 2505 |
1/2✓ Branch 0 taken 67 times.
✗ Branch 1 not taken.
|
67 | my_decimal *val0p = args[0]->val_decimal(&tmp); |
| 2506 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 65 times.
|
67 | if ((null_value = args[0]->null_value)) return 0; |
| 2507 |
1/2✓ Branch 0 taken 65 times.
✗ Branch 1 not taken.
|
65 | my_decimal val0 = *val0p; |
| 2508 | |||
| 2509 |
1/2✓ Branch 0 taken 65 times.
✗ Branch 1 not taken.
|
65 | my_decimal *val1p = args[1]->val_decimal(&tmp); |
| 2510 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 56 times.
|
65 | if ((null_value = args[1]->null_value)) return 0; |
| 2511 |
1/2✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
|
56 | my_decimal val1 = *val1p; |
| 2512 | |||
| 2513 | int err; | ||
| 2514 |
1/2✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
|
56 | if ((err = my_decimal_div(E_DEC_FATAL_ERROR & ~E_DEC_DIV_ZERO, &tmp, &val0, |
| 2515 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 53 times.
|
56 | &val1, 0)) > 3) { |
| 2516 |
2/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
|
3 | if (err == E_DEC_DIV_ZERO) signal_divide_by_null(); |
| 2517 | 3 | return 0; | |
| 2518 | } | ||
| 2519 | |||
| 2520 | 53 | my_decimal truncated; | |
| 2521 | 53 | const bool do_truncate = true; | |
| 2522 |
2/4✓ Branch 0 taken 53 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 53 times.
|
53 | if (my_decimal_round(E_DEC_FATAL_ERROR, &tmp, 0, do_truncate, &truncated)) |
| 2523 | ✗ | assert(false); | |
| 2524 | |||
| 2525 | longlong res; | ||
| 2526 |
3/4✓ Branch 0 taken 53 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 49 times.
|
53 | if (my_decimal2int(E_DEC_FATAL_ERROR, &truncated, unsigned_flag, &res) & |
| 2527 | E_DEC_OVERFLOW) | ||
| 2528 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | raise_integer_overflow(); |
| 2529 | 53 | return res; | |
| 2530 | 67 | } | |
| 2531 | |||
| 2532 | 124256 | longlong val0 = args[0]->val_int(); | |
| 2533 | 124256 | longlong val1 = args[1]->val_int(); | |
| 2534 | bool val0_negative, val1_negative, res_negative; | ||
| 2535 | ulonglong uval0, uval1, res; | ||
| 2536 |
6/6✓ Branch 0 taken 123399 times.
✓ Branch 1 taken 857 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 123398 times.
✓ Branch 4 taken 858 times.
✓ Branch 5 taken 123398 times.
|
124256 | if ((null_value = (args[0]->null_value || args[1]->null_value))) return 0; |
| 2537 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 123394 times.
|
123398 | if (val1 == 0) { |
| 2538 | 4 | signal_divide_by_null(); | |
| 2539 | 4 | return 0; | |
| 2540 | } | ||
| 2541 | |||
| 2542 |
4/4✓ Branch 0 taken 123308 times.
✓ Branch 1 taken 86 times.
✓ Branch 2 taken 11697 times.
✓ Branch 3 taken 111611 times.
|
123394 | val0_negative = !args[0]->unsigned_flag && val0 < 0; |
| 2543 |
3/4✓ Branch 0 taken 123394 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 123390 times.
|
123394 | val1_negative = !args[1]->unsigned_flag && val1 < 0; |
| 2544 | 123394 | res_negative = val0_negative != val1_negative; | |
| 2545 |
4/4✓ Branch 0 taken 11697 times.
✓ Branch 1 taken 111697 times.
✓ Branch 2 taken 11695 times.
✓ Branch 3 taken 2 times.
|
123394 | uval0 = (ulonglong)(val0_negative && val0 != LLONG_MIN ? -val0 : val0); |
| 2546 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 123390 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
123394 | uval1 = (ulonglong)(val1_negative && val1 != LLONG_MIN ? -val1 : val1); |
| 2547 | 123394 | res = uval0 / uval1; | |
| 2548 |
2/2✓ Branch 0 taken 11697 times.
✓ Branch 1 taken 111697 times.
|
123394 | if (res_negative) { |
| 2549 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 11696 times.
|
11697 | if (res > (ulonglong)LLONG_MAX) return raise_integer_overflow(); |
| 2550 | 11696 | res = (ulonglong)(-(longlong)res); | |
| 2551 | } | ||
| 2552 | 123393 | return check_integer_overflow(res, !res_negative); | |
| 2553 | } | ||
| 2554 | |||
| 2555 | 36304 | bool Item_func_div_int::resolve_type(THD *thd) { | |
| 2556 | // Integer division forces result to be integer, so force arguments | ||
| 2557 | // that are parameters to be integer as well. | ||
| 2558 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 36304 times.
|
36304 | if (param_type_uses_non_param(thd, MYSQL_TYPE_LONGLONG)) return true; |
| 2559 | |||
| 2560 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 36301 times.
|
36304 | if (Item_func_div_base::resolve_type(thd)) return true; |
| 2561 | 36301 | set_nullable(true); // division by zero | |
| 2562 | |||
| 2563 | 36301 | return false; | |
| 2564 | } | ||
| 2565 | |||
| 2566 | 36304 | void Item_func_div_int::set_numeric_type() { | |
| 2567 | 36304 | set_data_type_longlong(); | |
| 2568 | 36304 | hybrid_type = INT_RESULT; | |
| 2569 | 36304 | result_precision(); | |
| 2570 | 36304 | } | |
| 2571 | |||
| 2572 | 12840749 | longlong Item_func_mod::int_op() { | |
| 2573 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12840749 times.
|
12840749 | assert(fixed == 1); |
| 2574 | 12840749 | longlong val0 = args[0]->val_int(); | |
| 2575 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 12840751 times.
|
12840753 | if (current_thd->is_error()) return error_int(); |
| 2576 | 12840751 | longlong val1 = args[1]->val_int(); | |
| 2577 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12840752 times.
|
12840752 | if (current_thd->is_error()) return error_int(); |
| 2578 | bool val0_negative, val1_negative; | ||
| 2579 | ulonglong uval0, uval1; | ||
| 2580 | ulonglong res; | ||
| 2581 | |||
| 2582 |
6/6✓ Branch 0 taken 12833555 times.
✓ Branch 1 taken 7197 times.
✓ Branch 2 taken 6565 times.
✓ Branch 3 taken 12826990 times.
✓ Branch 4 taken 13762 times.
✓ Branch 5 taken 12826990 times.
|
12840752 | if ((null_value = args[0]->null_value || args[1]->null_value)) |
| 2583 | 13762 | return 0; /* purecov: inspected */ | |
| 2584 |
2/2✓ Branch 0 taken 3988 times.
✓ Branch 1 taken 12823002 times.
|
12826990 | if (val1 == 0) { |
| 2585 | 3988 | signal_divide_by_null(); | |
| 2586 | 3988 | return 0; | |
| 2587 | } | ||
| 2588 | |||
| 2589 | /* | ||
| 2590 | '%' is calculated by integer division internally. Since dividing | ||
| 2591 | LLONG_MIN by -1 generates SIGFPE, we calculate using unsigned values and | ||
| 2592 | then adjust the sign appropriately. | ||
| 2593 | */ | ||
| 2594 |
4/4✓ Branch 0 taken 12778151 times.
✓ Branch 1 taken 44851 times.
✓ Branch 2 taken 36667 times.
✓ Branch 3 taken 12741484 times.
|
12823002 | val0_negative = !args[0]->unsigned_flag && val0 < 0; |
| 2595 |
4/4✓ Branch 0 taken 12820846 times.
✓ Branch 1 taken 2156 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 12820841 times.
|
12823002 | val1_negative = !args[1]->unsigned_flag && val1 < 0; |
| 2596 |
4/4✓ Branch 0 taken 36667 times.
✓ Branch 1 taken 12786335 times.
✓ Branch 2 taken 36664 times.
✓ Branch 3 taken 3 times.
|
12823002 | uval0 = (ulonglong)(val0_negative && val0 != LLONG_MIN ? -val0 : val0); |
| 2597 |
3/4✓ Branch 0 taken 5 times.
✓ Branch 1 taken 12822997 times.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
12823002 | uval1 = (ulonglong)(val1_negative && val1 != LLONG_MIN ? -val1 : val1); |
| 2598 | 12823002 | res = uval0 % uval1; | |
| 2599 | MY_COMPILER_DIAGNOSTIC_PUSH() | ||
| 2600 | // Suppress warning C4146 unary minus operator applied to unsigned type, | ||
| 2601 | // result still unsigned | ||
| 2602 | MY_COMPILER_MSVC_DIAGNOSTIC_IGNORE(4146) | ||
| 2603 |
2/2✓ Branch 0 taken 36667 times.
✓ Branch 1 taken 12786335 times.
|
12823002 | return check_integer_overflow(val0_negative ? -res : res, !val0_negative); |
| 2604 | MY_COMPILER_DIAGNOSTIC_POP() | ||
| 2605 | } | ||
| 2606 | |||
| 2607 | 100245 | double Item_func_mod::real_op() { | |
| 2608 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100245 times.
|
100245 | assert(fixed == 1); |
| 2609 | 100245 | double val1 = args[0]->val_real(); | |
| 2610 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 100244 times.
|
100245 | if (current_thd->is_error()) return error_real(); |
| 2611 | 100244 | double val2 = args[1]->val_real(); | |
| 2612 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100244 times.
|
100244 | if (current_thd->is_error()) return error_real(); |
| 2613 | |||
| 2614 |
6/6✓ Branch 0 taken 100224 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 100215 times.
✓ Branch 4 taken 29 times.
✓ Branch 5 taken 100215 times.
|
100244 | if ((null_value = args[0]->null_value || args[1]->null_value)) return 0.0; |
| 2615 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 100211 times.
|
100215 | if (val2 == 0.0) { |
| 2616 | 4 | signal_divide_by_null(); | |
| 2617 | 4 | return 0.0; | |
| 2618 | } | ||
| 2619 | 100211 | return fmod(val1, val2); | |
| 2620 | } | ||
| 2621 | |||
| 2622 | 78 | my_decimal *Item_func_mod::decimal_op(my_decimal *decimal_value) { | |
| 2623 | 78 | my_decimal value1, *val1; | |
| 2624 | 78 | my_decimal value2, *val2; | |
| 2625 | |||
| 2626 |
1/2✓ Branch 0 taken 78 times.
✗ Branch 1 not taken.
|
78 | val1 = args[0]->val_decimal(&value1); |
| 2627 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 74 times.
|
78 | if ((null_value = args[0]->null_value)) return nullptr; |
| 2628 |
1/2✓ Branch 0 taken 74 times.
✗ Branch 1 not taken.
|
74 | val2 = args[1]->val_decimal(&value2); |
| 2629 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
|
74 | if ((null_value = args[1]->null_value)) return nullptr; |
| 2630 |
3/5✓ Branch 0 taken 74 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.
|
74 | switch (my_decimal_mod(E_DEC_FATAL_ERROR & ~E_DEC_DIV_ZERO, decimal_value, |
| 2631 | val1, val2)) { | ||
| 2632 | 65 | case E_DEC_TRUNCATED: | |
| 2633 | case E_DEC_OK: | ||
| 2634 | 65 | return decimal_value; | |
| 2635 | 9 | case E_DEC_DIV_ZERO: | |
| 2636 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | signal_divide_by_null(); |
| 2637 | [[fallthrough]]; | ||
| 2638 | 9 | default: | |
| 2639 | 9 | null_value = true; | |
| 2640 | 9 | return nullptr; | |
| 2641 | } | ||
| 2642 | 78 | } | |
| 2643 | |||
| 2644 | 82350 | void Item_func_mod::result_precision() { | |
| 2645 | 82350 | decimals = max(args[0]->decimals, args[1]->decimals); | |
| 2646 | uint precision = | ||
| 2647 |
1/2✓ Branch 0 taken 82350 times.
✗ Branch 1 not taken.
|
82350 | max(args[0]->decimal_precision(), args[1]->decimal_precision()); |
| 2648 | |||
| 2649 | 164700 | max_length = my_decimal_precision_to_length_no_truncation(precision, decimals, | |
| 2650 | 82350 | unsigned_flag); | |
| 2651 | |||
| 2652 | // Increase max_length if we have: signed % unsigned(precision == scale) | ||
| 2653 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 81845 times.
|
81848 | if (!args[0]->unsigned_flag && args[1]->unsigned_flag && |
| 2654 |
5/6✓ Branch 0 taken 81848 times.
✓ Branch 1 taken 502 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 82350 times.
|
164200 | args[0]->max_length <= args[1]->max_length && |
| 2655 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | args[1]->decimals == args[1]->decimal_precision()) { |
| 2656 | ✗ | max_length += 1; | |
| 2657 | } | ||
| 2658 | 82350 | } | |
| 2659 | |||
| 2660 | 90544 | bool Item_func_mod::resolve_type(THD *thd) { | |
| 2661 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 90541 times.
|
90544 | if (Item_num_op::resolve_type(thd)) return true; |
| 2662 | 90541 | set_nullable(true); | |
| 2663 | 90541 | unsigned_flag = args[0]->unsigned_flag; | |
| 2664 | 90541 | return false; | |
| 2665 | } | ||
| 2666 | |||
| 2667 | 4130 | double Item_func_neg::real_op() { | |
| 2668 | 4130 | double value = args[0]->val_real(); | |
| 2669 | 4130 | null_value = args[0]->null_value; | |
| 2670 | 4130 | return -value; | |
| 2671 | } | ||
| 2672 | |||
| 2673 | 439140 | longlong Item_func_neg::int_op() { | |
| 2674 | 439140 | longlong value = args[0]->val_int(); | |
| 2675 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 439120 times.
|
439141 | if ((null_value = args[0]->null_value)) return 0; |
| 2676 |
4/4✓ Branch 0 taken 779 times.
✓ Branch 1 taken 438341 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 778 times.
|
439120 | if (args[0]->unsigned_flag && (ulonglong)value > (ulonglong)LLONG_MAX + 1ULL) |
| 2677 | 1 | return raise_integer_overflow(); | |
| 2678 | // For some platforms we need special handling of LLONG_MIN to | ||
| 2679 | // guarantee overflow. | ||
| 2680 |
5/6✓ Branch 0 taken 780 times.
✓ Branch 1 taken 438339 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 778 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
|
439119 | if (value == LLONG_MIN && !args[0]->unsigned_flag && !unsigned_flag) |
| 2681 | 2 | return raise_integer_overflow(); | |
| 2682 | // Avoid doing '-value' below, it is undefined. | ||
| 2683 |
4/6✓ Branch 0 taken 778 times.
✓ Branch 1 taken 438339 times.
✓ Branch 2 taken 778 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 778 times.
✗ Branch 5 not taken.
|
439117 | if (value == LLONG_MIN && args[0]->unsigned_flag && !unsigned_flag) |
| 2684 | 778 | return LLONG_MIN; | |
| 2685 |
4/4✓ Branch 0 taken 438338 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 70100 times.
✓ Branch 3 taken 368238 times.
|
438339 | return check_integer_overflow(-value, !args[0]->unsigned_flag && value < 0); |
| 2686 | } | ||
| 2687 | |||
| 2688 | 5161 | my_decimal *Item_func_neg::decimal_op(my_decimal *decimal_value) { | |
| 2689 |
1/2✓ Branch 0 taken 5161 times.
✗ Branch 1 not taken.
|
5161 | my_decimal val, *value = args[0]->val_decimal(&val); |
| 2690 |
1/2✓ Branch 0 taken 5161 times.
✗ Branch 1 not taken.
|
5161 | if (!(null_value = args[0]->null_value)) { |
| 2691 |
1/2✓ Branch 0 taken 5161 times.
✗ Branch 1 not taken.
|
5161 | my_decimal2decimal(value, decimal_value); |
| 2692 |
1/2✓ Branch 0 taken 5161 times.
✗ Branch 1 not taken.
|
5161 | my_decimal_neg(decimal_value); |
| 2693 | 5161 | return decimal_value; | |
| 2694 | } | ||
| 2695 | ✗ | return nullptr; | |
| 2696 | 5161 | } | |
| 2697 | |||
| 2698 | 177251 | void Item_func_neg::fix_num_length_and_dec() { | |
| 2699 | 177251 | decimals = args[0]->decimals; | |
| 2700 |
2/2✓ Branch 0 taken 559 times.
✓ Branch 1 taken 176692 times.
|
177251 | max_length = args[0]->max_length + (args[0]->unsigned_flag ? 1 : 0); |
| 2701 | // Booleans have max_length = 1, but need to add the minus sign | ||
| 2702 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 177246 times.
|
177251 | if (max_length == 1) max_length++; |
| 2703 | 177251 | } | |
| 2704 | |||
| 2705 | 177251 | bool Item_func_neg::resolve_type(THD *thd) { | |
| 2706 |
1/2✓ Branch 0 taken 177251 times.
✗ Branch 1 not taken.
|
177251 | DBUG_TRACE; |
| 2707 |
3/4✓ Branch 0 taken 177251 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 177250 times.
|
177251 | if (Item_func_num1::resolve_type(thd)) return true; |
| 2708 | /* | ||
| 2709 | If this is in integer context keep the context as integer if possible | ||
| 2710 | (This is how multiplication and other integer functions works) | ||
| 2711 | Use val() to get value as arg_type doesn't mean that item is | ||
| 2712 | Item_int or Item_real due to existence of Item_param. | ||
| 2713 | */ | ||
| 2714 |
7/8✓ Branch 0 taken 173520 times.
✓ Branch 1 taken 3730 times.
✓ Branch 2 taken 173520 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 112690 times.
✓ Branch 5 taken 60830 times.
✓ Branch 6 taken 112688 times.
✓ Branch 7 taken 64562 times.
|
289940 | if (hybrid_type == INT_RESULT && args[0]->const_item() && |
| 2715 |
3/4✓ Branch 0 taken 112690 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 112688 times.
✓ Branch 3 taken 2 times.
|
112690 | args[0]->may_eval_const_item(thd)) { |
| 2716 |
1/2✓ Branch 0 taken 112688 times.
✗ Branch 1 not taken.
|
112688 | longlong val = args[0]->val_int(); |
| 2717 |
6/6✓ Branch 0 taken 572 times.
✓ Branch 1 taken 112116 times.
✓ Branch 2 taken 360 times.
✓ Branch 3 taken 212 times.
✓ Branch 4 taken 218 times.
✓ Branch 5 taken 112470 times.
|
113048 | if ((ulonglong)val >= (ulonglong)LLONG_MIN && |
| 2718 | 360 | ((ulonglong)val != (ulonglong)LLONG_MIN || | |
| 2719 |
3/4✓ Branch 0 taken 360 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 354 times.
|
360 | args[0]->type() != INT_ITEM)) { |
| 2720 | /* | ||
| 2721 | Ensure that result is converted to DECIMAL, as longlong can't hold | ||
| 2722 | the negated number | ||
| 2723 | */ | ||
| 2724 | 218 | unsigned_flag = false; | |
| 2725 |
2/4✓ Branch 0 taken 218 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 218 times.
✗ Branch 3 not taken.
|
218 | set_data_type_decimal(args[0]->decimal_precision(), 0); |
| 2726 | 218 | hybrid_type = DECIMAL_RESULT; | |
| 2727 |
3/8✓ Branch 0 taken 218 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 218 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 218 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
218 | DBUG_PRINT("info", ("Type changed: DECIMAL_RESULT")); |
| 2728 | } | ||
| 2729 | } | ||
| 2730 | 177250 | unsigned_flag = false; | |
| 2731 | 177250 | return false; | |
| 2732 | 177251 | } | |
| 2733 | |||
| 2734 | 202 | double Item_func_abs::real_op() { | |
| 2735 | 202 | double value = args[0]->val_real(); | |
| 2736 | 202 | null_value = args[0]->null_value; | |
| 2737 | 202 | return fabs(value); | |
| 2738 | } | ||
| 2739 | |||
| 2740 | 849694 | longlong Item_func_abs::int_op() { | |
| 2741 | 849694 | longlong value = args[0]->val_int(); | |
| 2742 |
2/2✓ Branch 0 taken 1813 times.
✓ Branch 1 taken 847881 times.
|
849694 | if ((null_value = args[0]->null_value)) return 0; |
| 2743 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 847872 times.
|
847881 | if (unsigned_flag) return value; |
| 2744 | /* -LLONG_MIN = LLONG_MAX + 1 => outside of signed longlong range */ | ||
| 2745 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 847871 times.
|
847872 | if (value == LLONG_MIN) return raise_integer_overflow(); |
| 2746 | 847871 | return (value >= 0) ? value : -value; | |
| 2747 | } | ||
| 2748 | |||
| 2749 | 10 | my_decimal *Item_func_abs::decimal_op(my_decimal *decimal_value) { | |
| 2750 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | my_decimal val, *value = args[0]->val_decimal(&val); |
| 2751 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 1 times.
|
10 | if (!(null_value = args[0]->null_value)) { |
| 2752 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | my_decimal2decimal(value, decimal_value); |
| 2753 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
9 | if (decimal_value->sign()) my_decimal_neg(decimal_value); |
| 2754 | 9 | return decimal_value; | |
| 2755 | } | ||
| 2756 | 1 | return nullptr; | |
| 2757 | 10 | } | |
| 2758 | |||
| 2759 | 9390 | bool Item_func_abs::resolve_type(THD *thd) { | |
| 2760 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 9389 times.
|
9390 | if (Item_func_num1::resolve_type(thd)) return true; |
| 2761 | 9389 | unsigned_flag = args[0]->unsigned_flag; | |
| 2762 | 9389 | return false; | |
| 2763 | } | ||
| 2764 | |||
| 2765 | 1123 | bool Item_dec_func::resolve_type(THD *thd) { | |
| 2766 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1123 times.
|
1123 | if (param_type_is_default(thd, 0, -1, MYSQL_TYPE_DOUBLE)) return true; |
| 2767 | 1123 | decimals = DECIMAL_NOT_SPECIFIED; | |
| 2768 | 1123 | max_length = float_length(decimals); | |
| 2769 | 1123 | set_nullable(true); | |
| 2770 | 1123 | return reject_geometry_args(arg_count, args, this); | |
| 2771 | } | ||
| 2772 | |||
| 2773 | /** Gateway to natural LOG function. */ | ||
| 2774 | 44 | double Item_func_ln::val_real() { | |
| 2775 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 44 times.
|
44 | assert(fixed == 1); |
| 2776 | 44 | double value = args[0]->val_real(); | |
| 2777 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 43 times.
|
44 | if ((null_value = args[0]->null_value)) return 0.0; |
| 2778 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 11 times.
|
43 | if (value <= 0.0) { |
| 2779 | 32 | signal_invalid_argument_for_log(); | |
| 2780 | 32 | return 0.0; | |
| 2781 | } | ||
| 2782 | 11 | return log(value); | |
| 2783 | } | ||
| 2784 | |||
| 2785 | /** | ||
| 2786 | Extended but so slower LOG function. | ||
| 2787 | |||
| 2788 | We have to check if all values are > zero and first one is not one | ||
| 2789 | as these are the cases then result is not a number. | ||
| 2790 | */ | ||
| 2791 | 41 | double Item_func_log::val_real() { | |
| 2792 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
|
41 | assert(fixed == 1); |
| 2793 | 41 | double value = args[0]->val_real(); | |
| 2794 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 39 times.
|
41 | if ((null_value = args[0]->null_value)) return 0.0; |
| 2795 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 32 times.
|
39 | if (value <= 0.0) { |
| 2796 | 7 | signal_invalid_argument_for_log(); | |
| 2797 | 7 | return 0.0; | |
| 2798 | } | ||
| 2799 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 16 times.
|
32 | if (arg_count == 2) { |
| 2800 | 16 | double value2 = args[1]->val_real(); | |
| 2801 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
|
16 | if ((null_value = args[1]->null_value)) return 0.0; |
| 2802 |
4/4✓ Branch 0 taken 13 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 10 times.
|
16 | if (value2 <= 0.0 || value == 1.0) { |
| 2803 | 6 | signal_invalid_argument_for_log(); | |
| 2804 | 6 | return 0.0; | |
| 2805 | } | ||
| 2806 | 10 | return log(value2) / log(value); | |
| 2807 | } | ||
| 2808 | 16 | return log(value); | |
| 2809 | } | ||
| 2810 | |||
| 2811 | 25 | double Item_func_log2::val_real() { | |
| 2812 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
|
25 | assert(fixed == 1); |
| 2813 | 25 | double value = args[0]->val_real(); | |
| 2814 | |||
| 2815 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 23 times.
|
25 | if ((null_value = args[0]->null_value)) return 0.0; |
| 2816 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 16 times.
|
23 | if (value <= 0.0) { |
| 2817 | 7 | signal_invalid_argument_for_log(); | |
| 2818 | 7 | return 0.0; | |
| 2819 | } | ||
| 2820 | 16 | return std::log2(value); | |
| 2821 | } | ||
| 2822 | |||
| 2823 | 34 | double Item_func_log10::val_real() { | |
| 2824 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | assert(fixed == 1); |
| 2825 | 34 | double value = args[0]->val_real(); | |
| 2826 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 30 times.
|
34 | if ((null_value = args[0]->null_value)) return 0.0; |
| 2827 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 22 times.
|
30 | if (value <= 0.0) { |
| 2828 | 8 | signal_invalid_argument_for_log(); | |
| 2829 | 8 | return 0.0; | |
| 2830 | } | ||
| 2831 | 22 | return log10(value); | |
| 2832 | } | ||
| 2833 | |||
| 2834 | 47 | double Item_func_exp::val_real() { | |
| 2835 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 47 times.
|
47 | assert(fixed == 1); |
| 2836 | 47 | double value = args[0]->val_real(); | |
| 2837 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 47 times.
|
47 | if ((null_value = args[0]->null_value)) return 0.0; /* purecov: inspected */ |
| 2838 | 47 | return check_float_overflow(exp(value)); | |
| 2839 | } | ||
| 2840 | |||
| 2841 | 820 | double Item_func_sqrt::val_real() { | |
| 2842 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 820 times.
|
820 | assert(fixed == 1); |
| 2843 | 820 | double value = args[0]->val_real(); | |
| 2844 |
6/6✓ Branch 0 taken 785 times.
✓ Branch 1 taken 35 times.
✓ Branch 2 taken 23 times.
✓ Branch 3 taken 762 times.
✓ Branch 4 taken 58 times.
✓ Branch 5 taken 762 times.
|
820 | if ((null_value = (args[0]->null_value || value < 0))) |
| 2845 | 58 | return 0.0; /* purecov: inspected */ | |
| 2846 | 762 | return sqrt(value); | |
| 2847 | } | ||
| 2848 | |||
| 2849 | 7179 | double Item_func_pow::val_real() { | |
| 2850 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7179 times.
|
7179 | assert(fixed == 1); |
| 2851 | 7179 | double value = args[0]->val_real(); | |
| 2852 | 7179 | double val2 = args[1]->val_real(); | |
| 2853 |
3/6✓ Branch 0 taken 7179 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7179 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 7179 times.
|
7179 | if ((null_value = (args[0]->null_value || args[1]->null_value))) |
| 2854 | ✗ | return 0.0; /* purecov: inspected */ | |
| 2855 | 7179 | const double pow_result = pow(value, val2); | |
| 2856 | 7179 | return check_float_overflow(pow_result); | |
| 2857 | } | ||
| 2858 | |||
| 2859 | // Trigonometric functions | ||
| 2860 | |||
| 2861 | 29 | double Item_func_acos::val_real() { | |
| 2862 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29 times.
|
29 | assert(fixed == 1); |
| 2863 | /* One can use this to defer SELECT processing. */ | ||
| 2864 |
1/2✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
|
29 | DEBUG_SYNC(current_thd, "before_acos_function"); |
| 2865 | 29 | double value = args[0]->val_real(); | |
| 2866 |
6/8✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 24 times.
✓ Branch 6 taken 5 times.
✓ Branch 7 taken 24 times.
|
29 | if ((null_value = (args[0]->null_value || (value < -1.0 || value > 1.0)))) |
| 2867 | 5 | return 0.0; | |
| 2868 | 24 | return acos(value); | |
| 2869 | } | ||
| 2870 | |||
| 2871 | 24 | double Item_func_asin::val_real() { | |
| 2872 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
|
24 | assert(fixed == 1); |
| 2873 | 24 | double value = args[0]->val_real(); | |
| 2874 |
7/8✓ Branch 0 taken 22 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 22 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 18 times.
✓ Branch 6 taken 6 times.
✓ Branch 7 taken 18 times.
|
24 | if ((null_value = (args[0]->null_value || (value < -1.0 || value > 1.0)))) |
| 2875 | 6 | return 0.0; | |
| 2876 | 18 | return asin(value); | |
| 2877 | } | ||
| 2878 | |||
| 2879 | 41 | double Item_func_atan::val_real() { | |
| 2880 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
|
41 | assert(fixed == 1); |
| 2881 | 41 | double value = args[0]->val_real(); | |
| 2882 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
|
41 | if ((null_value = args[0]->null_value)) return 0.0; |
| 2883 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 20 times.
|
41 | if (arg_count == 2) { |
| 2884 | 21 | double val2 = args[1]->val_real(); | |
| 2885 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
|
21 | if ((null_value = args[1]->null_value)) return 0.0; |
| 2886 | 21 | return check_float_overflow(atan2(value, val2)); | |
| 2887 | } | ||
| 2888 | 20 | return atan(value); | |
| 2889 | } | ||
| 2890 | |||
| 2891 | 22 | double Item_func_cos::val_real() { | |
| 2892 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | assert(fixed == 1); |
| 2893 | 22 | double value = args[0]->val_real(); | |
| 2894 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if ((null_value = args[0]->null_value)) return 0.0; |
| 2895 | 22 | return cos(value); | |
| 2896 | } | ||
| 2897 | |||
| 2898 | 94 | double Item_func_sin::val_real() { | |
| 2899 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 94 times.
|
94 | assert(fixed == 1); |
| 2900 | 94 | double value = args[0]->val_real(); | |
| 2901 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 93 times.
|
94 | if ((null_value = args[0]->null_value)) return 0.0; |
| 2902 | 93 | return sin(value); | |
| 2903 | } | ||
| 2904 | |||
| 2905 | 19 | double Item_func_tan::val_real() { | |
| 2906 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
|
19 | assert(fixed == 1); |
| 2907 | 19 | double value = args[0]->val_real(); | |
| 2908 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
|
19 | if ((null_value = args[0]->null_value)) return 0.0; |
| 2909 | 19 | return check_float_overflow(tan(value)); | |
| 2910 | } | ||
| 2911 | |||
| 2912 | 18 | double Item_func_cot::val_real() { | |
| 2913 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
|
18 | assert(fixed == 1); |
| 2914 | 18 | double value = args[0]->val_real(); | |
| 2915 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 15 times.
|
18 | if ((null_value = args[0]->null_value)) return 0.0; |
| 2916 | 15 | double val2 = tan(value); | |
| 2917 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 5 times.
|
15 | if (val2 == 0.0) { |
| 2918 | 10 | return raise_float_overflow(); | |
| 2919 | } | ||
| 2920 | 5 | return check_float_overflow(1.0 / val2); | |
| 2921 | } | ||
| 2922 | |||
| 2923 | // Bitwise functions | ||
| 2924 | |||
| 2925 | 214593 | bool Item_func_bit::resolve_type(THD *thd) { | |
| 2926 | 214593 | const bool second_arg = binary_result_requires_binary_second_arg(); | |
| 2927 | /* | ||
| 2928 | In ?&?, we assume varbinary; if integer is provided we'll re-prepare. | ||
| 2929 | To force var*binary*, we temporarily change the charset: | ||
| 2930 | */ | ||
| 2931 | 214593 | const CHARSET_INFO *save_cs = thd->variables.collation_connection; | |
| 2932 | 214593 | thd->variables.collation_connection = &my_charset_bin; | |
| 2933 |
2/2✓ Branch 0 taken 70382 times.
✓ Branch 1 taken 144211 times.
|
214593 | if (second_arg) { |
| 2934 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 70382 times.
|
70382 | if (param_type_uses_non_param(thd)) return true; |
| 2935 | } else { | ||
| 2936 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 144211 times.
|
144211 | if (param_type_is_default(thd, 0, 1)) return true; |
| 2937 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 144211 times.
|
144211 | if (param_type_is_default(thd, 1, 2, MYSQL_TYPE_LONGLONG)) return true; |
| 2938 | } | ||
| 2939 | 214593 | thd->variables.collation_connection = save_cs; | |
| 2940 |
4/4✓ Branch 0 taken 70382 times.
✓ Branch 1 taken 144211 times.
✓ Branch 2 taken 588 times.
✓ Branch 3 taken 214005 times.
|
214593 | if (bit_func_returns_binary(args[0], second_arg ? args[1] : nullptr)) { |
| 2941 | 588 | hybrid_type = STRING_RESULT; | |
| 2942 | 588 | set_data_type_string( | |
| 2943 |
2/2✓ Branch 0 taken 308 times.
✓ Branch 1 taken 280 times.
|
1176 | max<uint32>(args[0]->max_length, second_arg ? args[1]->max_length : 0U), |
| 2944 | &my_charset_bin); | ||
| 2945 | } else { | ||
| 2946 | 214005 | hybrid_type = INT_RESULT; | |
| 2947 | 214005 | set_data_type_longlong(); | |
| 2948 | 214005 | unsigned_flag = true; | |
| 2949 | } | ||
| 2950 | 214593 | return reject_geometry_args(arg_count, args, this); | |
| 2951 | } | ||
| 2952 | |||
| 2953 | 211578 | longlong Item_func_bit::val_int() { | |
| 2954 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 211578 times.
|
211578 | assert(fixed); |
| 2955 |
2/2✓ Branch 0 taken 211575 times.
✓ Branch 1 taken 3 times.
|
211578 | if (hybrid_type == INT_RESULT) |
| 2956 | 211575 | return int_op(); | |
| 2957 | else { | ||
| 2958 | String *res; | ||
| 2959 |
3/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2 times.
|
3 | if (!(res = str_op(&str_value))) return 0; |
| 2960 | |||
| 2961 | int ovf_error; | ||
| 2962 | 2 | const char *from = res->ptr(); | |
| 2963 | 2 | size_t len = res->length(); | |
| 2964 | 2 | const char *end = from + len; | |
| 2965 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | return my_strtoll10(from, &end, &ovf_error); |
| 2966 | } | ||
| 2967 | } | ||
| 2968 | |||
| 2969 | 28 | double Item_func_bit::val_real() { | |
| 2970 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
|
28 | assert(fixed); |
| 2971 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 14 times.
|
28 | if (hybrid_type == INT_RESULT) |
| 2972 | 14 | return static_cast<ulonglong>(int_op()); | |
| 2973 | else { | ||
| 2974 | String *res; | ||
| 2975 |
3/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 12 times.
|
14 | if (!(res = str_op(&str_value))) return 0.0; |
| 2976 | |||
| 2977 | int ovf_error; | ||
| 2978 | 12 | const char *from = res->ptr(); | |
| 2979 | 12 | size_t len = res->length(); | |
| 2980 | 12 | const char *end = from + len; | |
| 2981 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | return my_strtod(from, &end, &ovf_error); |
| 2982 | } | ||
| 2983 | } | ||
| 2984 | |||
| 2985 | 32477 | my_decimal *Item_func_bit::val_decimal(my_decimal *decimal_value) { | |
| 2986 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32477 times.
|
32477 | assert(fixed); |
| 2987 |
2/2✓ Branch 0 taken 32476 times.
✓ Branch 1 taken 1 times.
|
32477 | if (hybrid_type == INT_RESULT) |
| 2988 | 32476 | return val_decimal_from_int(decimal_value); | |
| 2989 | else | ||
| 2990 | 1 | return val_decimal_from_string(decimal_value); | |
| 2991 | } | ||
| 2992 | |||
| 2993 | 2026 | String *Item_func_bit::val_str(String *str) { | |
| 2994 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2026 times.
|
2026 | assert(fixed); |
| 2995 |
2/2✓ Branch 0 taken 67 times.
✓ Branch 1 taken 1959 times.
|
2026 | if (hybrid_type == INT_RESULT) { |
| 2996 | 67 | longlong nr = int_op(); | |
| 2997 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 66 times.
|
67 | if (null_value) return nullptr; |
| 2998 | 66 | str->set_int(nr, unsigned_flag, collation.collation); | |
| 2999 | 66 | return str; | |
| 3000 | } else | ||
| 3001 | 1959 | return str_op(str); | |
| 3002 | } | ||
| 3003 | |||
| 3004 | // Shift-functions, same as << and >> in C/C++ | ||
| 3005 | |||
| 3006 | /** | ||
| 3007 | Template function that evaluates the bitwise shift operation over integer | ||
| 3008 | arguments. | ||
| 3009 | @tparam to_left True if left-shift, false if right-shift | ||
| 3010 | */ | ||
| 3011 | template <bool to_left> | ||
| 3012 | 286690 | longlong Item_func_shift::eval_int_op() { | |
| 3013 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 143345 times.
|
286690 | assert(fixed); |
| 3014 | 286690 | ulonglong res = args[0]->val_uint(); | |
| 3015 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 143335 times.
|
286690 | if (args[0]->null_value) return error_int(); |
| 3016 | |||
| 3017 | 286670 | ulonglong shift = args[1]->val_uint(); | |
| 3018 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 143322 times.
|
286670 | if (args[1]->null_value) return error_int(); |
| 3019 | |||
| 3020 | 286644 | null_value = false; | |
| 3021 |
2/2✓ Branch 0 taken 143307 times.
✓ Branch 1 taken 15 times.
|
286644 | if (shift < sizeof(longlong) * 8) |
| 3022 | 286614 | return to_left ? (res << shift) : (res >> shift); | |
| 3023 | 30 | return 0; | |
| 3024 | } | ||
| 3025 | |||
| 3026 | /// Instantiations of the above | ||
| 3027 | template longlong Item_func_shift::eval_int_op<true>(); | ||
| 3028 | template longlong Item_func_shift::eval_int_op<false>(); | ||
| 3029 | |||
| 3030 | /** | ||
| 3031 | Template function that evaluates the bitwise shift operation over binary | ||
| 3032 | string arguments. | ||
| 3033 | @tparam to_left True if left-shift, false if right-shift | ||
| 3034 | */ | ||
| 3035 | template <bool to_left> | ||
| 3036 | 806 | String *Item_func_shift::eval_str_op(String *) { | |
| 3037 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 403 times.
|
806 | assert(fixed); |
| 3038 | |||
| 3039 | 806 | String tmp_str; | |
| 3040 |
1/2✓ Branch 0 taken 403 times.
✗ Branch 1 not taken.
|
806 | String *arg = args[0]->val_str(&tmp_str); |
| 3041 |
4/6✓ Branch 0 taken 402 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 402 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
806 | if (!arg || args[0]->null_value) return error_str(); |
| 3042 | |||
| 3043 | 804 | ssize_t arg_length = arg->length(); | |
| 3044 | 804 | size_t shift = | |
| 3045 |
1/2✓ Branch 0 taken 402 times.
✗ Branch 1 not taken.
|
804 | min(args[1]->val_uint(), static_cast<ulonglong>(arg_length) * 8); |
| 3046 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 400 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
804 | if (args[1]->null_value) return error_str(); |
| 3047 | |||
| 3048 |
2/6✓ Branch 0 taken 400 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 400 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
800 | if (tmp_value.alloc(arg->length())) return error_str(); |
| 3049 | |||
| 3050 | 800 | tmp_value.length(arg_length); | |
| 3051 | 800 | tmp_value.set_charset(&my_charset_bin); | |
| 3052 | /* | ||
| 3053 | Example with left-shift-by-21-bits: | ||
| 3054 | |........|........|........|........| | ||
| 3055 | byte i byte i+1 byte i+2 byte i+3 | ||
| 3056 | First (leftmost) bit has number 1. | ||
| 3057 | 21 = 2*8 + 5. | ||
| 3058 | Bits of number 1-3 of byte 'i' receive bits 22-24 i.e. the last 3 bits of | ||
| 3059 | byte 'i+2'. So, take byte 'i+2', shift it left by 5 bits, that puts the | ||
| 3060 | last 3 bits of byte 'i+2' in bits 1-3, and 0s elsewhere. | ||
| 3061 | Bits of number 4-8 of byte 'i' receive bits 25-39 i.e. the first 5 bits of | ||
| 3062 | byte 'i+3'. So, take byte 'i+3', shift it right by 3 bits, that puts the | ||
| 3063 | first 5 bits of byte 'i+3' in bits 4-8, and 0s elsewhere. | ||
| 3064 | In total, do OR of both results. | ||
| 3065 | */ | ||
| 3066 | 800 | size_t mod = shift % 8; | |
| 3067 | 800 | size_t mod_complement = 8 - mod; | |
| 3068 | 800 | ssize_t entire_bytes = shift / 8; | |
| 3069 | |||
| 3070 | 800 | const unsigned char *from_c = pointer_cast<const unsigned char *>(arg->ptr()); | |
| 3071 | 800 | unsigned char *to_c = pointer_cast<unsigned char *>(tmp_value.c_ptr_quick()); | |
| 3072 | |||
| 3073 | if (to_left) { | ||
| 3074 | // Bytes of lower index are overwritten by bytes of higher index | ||
| 3075 |
2/2✓ Branch 0 taken 1957 times.
✓ Branch 1 taken 202 times.
|
4318 | for (ssize_t i = 0; i < arg_length; i++) |
| 3076 |
2/2✓ Branch 0 taken 1215 times.
✓ Branch 1 taken 742 times.
|
3914 | if (i + entire_bytes + 1 < arg_length) |
| 3077 | 2430 | to_c[i] = (from_c[i + entire_bytes] << mod) | | |
| 3078 | 2430 | (from_c[i + entire_bytes + 1] >> mod_complement); | |
| 3079 |
2/2✓ Branch 0 taken 201 times.
✓ Branch 1 taken 541 times.
|
1484 | else if (i + entire_bytes + 1 == arg_length) |
| 3080 | 402 | to_c[i] = from_c[i + entire_bytes] << mod; | |
| 3081 | else | ||
| 3082 | 1082 | to_c[i] = 0; | |
| 3083 | } else { | ||
| 3084 | // Bytes of higher index are overwritten by bytes of lower index | ||
| 3085 |
2/2✓ Branch 0 taken 1950 times.
✓ Branch 1 taken 198 times.
|
4296 | for (ssize_t i = arg_length - 1; i >= 0; i--) |
| 3086 |
2/2✓ Branch 0 taken 1211 times.
✓ Branch 1 taken 739 times.
|
3900 | if (i > entire_bytes) |
| 3087 | 2422 | to_c[i] = (from_c[i - entire_bytes] >> mod) | | |
| 3088 | 2422 | (from_c[i - entire_bytes - 1] << mod_complement); | |
| 3089 |
2/2✓ Branch 0 taken 196 times.
✓ Branch 1 taken 543 times.
|
1478 | else if (i == entire_bytes) |
| 3090 | 392 | to_c[i] = from_c[i - entire_bytes] >> mod; | |
| 3091 | else | ||
| 3092 | 1086 | to_c[i] = 0; | |
| 3093 | } | ||
| 3094 | |||
| 3095 | 800 | null_value = false; | |
| 3096 | 800 | return &tmp_value; | |
| 3097 | 806 | } | |
| 3098 | |||
| 3099 | /// Instantiations of the above | ||
| 3100 | template String *Item_func_shift::eval_str_op<true>(String *); | ||
| 3101 | template String *Item_func_shift::eval_str_op<false>(String *); | ||
| 3102 | |||
| 3103 | // Bit negation ('~') | ||
| 3104 | |||
| 3105 | 43 | longlong Item_func_bit_neg::int_op() { | |
| 3106 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 43 times.
|
43 | assert(fixed); |
| 3107 | 43 | ulonglong res = (ulonglong)args[0]->val_int(); | |
| 3108 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 36 times.
|
43 | if (args[0]->null_value) return error_int(); |
| 3109 | 36 | null_value = false; | |
| 3110 | 36 | return ~res; | |
| 3111 | } | ||
| 3112 | |||
| 3113 | 141 | String *Item_func_bit_neg::str_op(String *str) { | |
| 3114 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 141 times.
|
141 | assert(fixed); |
| 3115 | 141 | String *res = args[0]->val_str(str); | |
| 3116 |
3/4✓ Branch 0 taken 139 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 139 times.
|
141 | if (args[0]->null_value || !res) return error_str(); |
| 3117 | |||
| 3118 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 139 times.
|
139 | if (tmp_value.alloc(res->length())) return error_str(); |
| 3119 | |||
| 3120 | 139 | size_t arg_length = res->length(); | |
| 3121 | 139 | tmp_value.length(arg_length); | |
| 3122 | 139 | tmp_value.set_charset(&my_charset_bin); | |
| 3123 | 139 | const unsigned char *from_c = pointer_cast<const unsigned char *>(res->ptr()); | |
| 3124 | 139 | unsigned char *to_c = pointer_cast<unsigned char *>(tmp_value.c_ptr_quick()); | |
| 3125 | 139 | size_t i = 0; | |
| 3126 |
2/2✓ Branch 0 taken 120 times.
✓ Branch 1 taken 139 times.
|
259 | while (i + sizeof(longlong) <= arg_length) { |
| 3127 | 120 | int8store(&to_c[i], ~(uint8korr(&from_c[i]))); | |
| 3128 | 120 | i += sizeof(longlong); | |
| 3129 | } | ||
| 3130 |
2/2✓ Branch 0 taken 274 times.
✓ Branch 1 taken 139 times.
|
413 | while (i < arg_length) { |
| 3131 | 274 | to_c[i] = ~from_c[i]; | |
| 3132 | 274 | i++; | |
| 3133 | } | ||
| 3134 | |||
| 3135 | 139 | null_value = false; | |
| 3136 | 139 | return &tmp_value; | |
| 3137 | } | ||
| 3138 | |||
| 3139 | /** | ||
| 3140 | Template function used to evaluate the bitwise operation over int arguments. | ||
| 3141 | |||
| 3142 | @param int_func The bitwise function. | ||
| 3143 | */ | ||
| 3144 | template <class Int_func> | ||
| 3145 | 136536 | longlong Item_func_bit_two_param::eval_int_op(Int_func int_func) { | |
| 3146 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 68268 times.
|
136536 | assert(fixed); |
| 3147 |
1/2✓ Branch 0 taken 68268 times.
✗ Branch 1 not taken.
|
136536 | ulonglong arg0 = args[0]->val_uint(); |
| 3148 |
2/2✓ Branch 0 taken 63 times.
✓ Branch 1 taken 68205 times.
|
136536 | if (args[0]->null_value) return error_int(); |
| 3149 |
1/2✓ Branch 0 taken 68205 times.
✗ Branch 1 not taken.
|
136410 | ulonglong arg1 = args[1]->val_uint(); |
| 3150 |
2/2✓ Branch 0 taken 41 times.
✓ Branch 1 taken 68164 times.
|
136410 | if (args[1]->null_value) return error_int(); |
| 3151 | 136328 | null_value = false; | |
| 3152 | 136328 | return (longlong)int_func(arg0, arg1); | |
| 3153 | } | ||
| 3154 | |||
| 3155 | /// Instantiations of the above | ||
| 3156 | template longlong Item_func_bit_two_param::eval_int_op<std::bit_or<ulonglong>>( | ||
| 3157 | std::bit_or<ulonglong>); | ||
| 3158 | template longlong Item_func_bit_two_param::eval_int_op<std::bit_and<ulonglong>>( | ||
| 3159 | std::bit_and<ulonglong>); | ||
| 3160 | template longlong Item_func_bit_two_param::eval_int_op<std::bit_xor<ulonglong>>( | ||
| 3161 | std::bit_xor<ulonglong>); | ||
| 3162 | |||
| 3163 | /** | ||
| 3164 | Template function that evaluates the bitwise operation over binary arguments. | ||
| 3165 | Checks that both arguments have same length and applies the bitwise operation | ||
| 3166 | |||
| 3167 | @param char_func The Bitwise function used to evaluate unsigned chars. | ||
| 3168 | @param int_func The Bitwise function used to evaluate unsigned long longs. | ||
| 3169 | */ | ||
| 3170 | template <class Char_func, class Int_func> | ||
| 3171 | 2864 | String *Item_func_bit_two_param::eval_str_op(String *, Char_func char_func, | |
| 3172 | Int_func int_func) { | ||
| 3173 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1432 times.
|
2864 | assert(fixed); |
| 3174 | 2864 | String arg0_buff; | |
| 3175 |
1/2✓ Branch 0 taken 1432 times.
✗ Branch 1 not taken.
|
2864 | String *s1 = args[0]->val_str(&arg0_buff); |
| 3176 | |||
| 3177 |
4/6✓ Branch 0 taken 1306 times.
✓ Branch 1 taken 126 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1306 times.
✓ Branch 4 taken 126 times.
✗ Branch 5 not taken.
|
2864 | if (args[0]->null_value || !s1) return error_str(); |
| 3178 | |||
| 3179 | 2612 | String arg1_buff; | |
| 3180 |
1/2✓ Branch 0 taken 1306 times.
✗ Branch 1 not taken.
|
2612 | String *s2 = args[1]->val_str(&arg1_buff); |
| 3181 | |||
| 3182 |
4/6✓ Branch 0 taken 1011 times.
✓ Branch 1 taken 295 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1011 times.
✓ Branch 4 taken 295 times.
✗ Branch 5 not taken.
|
2612 | if (args[1]->null_value || !s2) return error_str(); |
| 3183 | |||
| 3184 | 2022 | size_t arg_length = s1->length(); | |
| 3185 |
2/2✓ Branch 0 taken 26 times.
✓ Branch 1 taken 985 times.
|
2022 | if (arg_length != s2->length()) { |
| 3186 |
2/4✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
|
52 | my_error(ER_INVALID_BITWISE_OPERANDS_SIZE, MYF(0), func_name()); |
| 3187 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
52 | return error_str(); |
| 3188 | } | ||
| 3189 | |||
| 3190 |
2/6✓ Branch 0 taken 985 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 985 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
1970 | if (tmp_value.alloc(arg_length)) return error_str(); |
| 3191 | |||
| 3192 | 1970 | tmp_value.length(arg_length); | |
| 3193 | 1970 | tmp_value.set_charset(&my_charset_bin); | |
| 3194 | |||
| 3195 | 1970 | const uchar *s1_c_p = pointer_cast<const uchar *>(s1->ptr()); | |
| 3196 | 1970 | const uchar *s2_c_p = pointer_cast<const uchar *>(s2->ptr()); | |
| 3197 | 1970 | char *res = tmp_value.ptr(); | |
| 3198 | 1970 | size_t i = 0; | |
| 3199 |
2/2✓ Branch 0 taken 5135 times.
✓ Branch 1 taken 985 times.
|
12240 | while (i + sizeof(longlong) <= arg_length) { |
| 3200 | 10270 | int8store(&res[i], int_func(uint8korr(&s1_c_p[i]), uint8korr(&s2_c_p[i]))); | |
| 3201 | 10270 | i += sizeof(longlong); | |
| 3202 | } | ||
| 3203 |
2/2✓ Branch 0 taken 3082 times.
✓ Branch 1 taken 985 times.
|
8134 | while (i < arg_length) { |
| 3204 | 6164 | res[i] = char_func(s1_c_p[i], s2_c_p[i]); | |
| 3205 | 6164 | i++; | |
| 3206 | } | ||
| 3207 | |||
| 3208 | 1970 | null_value = false; | |
| 3209 | 1970 | return &tmp_value; | |
| 3210 | 2864 | } | |
| 3211 | |||
| 3212 | /// Instantiations of the above | ||
| 3213 | template String * | ||
| 3214 | Item_func_bit_two_param::eval_str_op<std::bit_or<char>, std::bit_or<ulonglong>>( | ||
| 3215 | String *, std::bit_or<char>, std::bit_or<ulonglong>); | ||
| 3216 | template String *Item_func_bit_two_param::eval_str_op< | ||
| 3217 | std::bit_and<char>, std::bit_and<ulonglong>>(String *, std::bit_and<char>, | ||
| 3218 | std::bit_and<ulonglong>); | ||
| 3219 | template String *Item_func_bit_two_param::eval_str_op< | ||
| 3220 | std::bit_xor<char>, std::bit_xor<ulonglong>>(String *, std::bit_xor<char>, | ||
| 3221 | std::bit_xor<ulonglong>); | ||
| 3222 | |||
| 3223 | 215708 | bool Item::bit_func_returns_binary(const Item *a, const Item *b) { | |
| 3224 | /* | ||
| 3225 | Checks if the bitwise function should return binary data. | ||
| 3226 | The conditions to return true are the following: | ||
| 3227 | |||
| 3228 | 1. If there's only one argument(so b is nullptr), | ||
| 3229 | then a must be a [VAR]BINARY Item, different from the hex/bit/NULL literal. | ||
| 3230 | |||
| 3231 | 2. If there are two arguments, both should be [VAR]BINARY | ||
| 3232 | and at least one of them should be different from the hex/bit/NULL literal | ||
| 3233 | */ | ||
| 3234 | // Check if a is [VAR]BINARY Item | ||
| 3235 |
2/2✓ Branch 0 taken 2635 times.
✓ Branch 1 taken 213073 times.
|
218343 | bool a_is_binary = a->result_type() == STRING_RESULT && |
| 3236 |
2/2✓ Branch 0 taken 2514 times.
✓ Branch 1 taken 121 times.
|
2635 | a->collation.collation == &my_charset_bin; |
| 3237 | // Check if b is not null and is [VAR]BINARY Item | ||
| 3238 |
4/4✓ Branch 0 taken 70382 times.
✓ Branch 1 taken 145326 times.
✓ Branch 2 taken 590 times.
✓ Branch 3 taken 69792 times.
|
216298 | bool b_is_binary = b && b->result_type() == STRING_RESULT && |
| 3239 |
2/2✓ Branch 0 taken 581 times.
✓ Branch 1 taken 9 times.
|
590 | b->collation.collation == &my_charset_bin; |
| 3240 | |||
| 3241 |
6/6✓ Branch 0 taken 2514 times.
✓ Branch 1 taken 213194 times.
✓ Branch 2 taken 1312 times.
✓ Branch 3 taken 1202 times.
✓ Branch 4 taken 414 times.
✓ Branch 5 taken 898 times.
|
217324 | return a_is_binary && (!b || b_is_binary) && |
| 3242 |
6/6✓ Branch 0 taken 1409 times.
✓ Branch 1 taken 207 times.
✓ Branch 2 taken 42 times.
✓ Branch 3 taken 1367 times.
✓ Branch 4 taken 163 times.
✓ Branch 5 taken 86 times.
|
1616 | ((a->type() != Item::VARBIN_ITEM && a->type() != Item::NULL_ITEM) || |
| 3243 |
2/2✓ Branch 0 taken 67 times.
✓ Branch 1 taken 96 times.
|
163 | (b && b->type() != Item::VARBIN_ITEM && |
| 3244 |
2/2✓ Branch 0 taken 57 times.
✓ Branch 1 taken 10 times.
|
215775 | b->type() != Item::NULL_ITEM)); |
| 3245 | } | ||
| 3246 | |||
| 3247 | // Conversion functions | ||
| 3248 | |||
| 3249 | 65301 | bool Item_func_int_val::resolve_type_inner(THD *) { | |
| 3250 |
1/2✓ Branch 0 taken 65301 times.
✗ Branch 1 not taken.
|
65301 | DBUG_TRACE; |
| 3251 |
3/10✓ Branch 0 taken 65301 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 65301 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 65301 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
65301 | DBUG_PRINT("info", ("name %s", func_name())); |
| 3252 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65301 times.
|
65301 | assert(args[0]->data_type() != MYSQL_TYPE_INVALID); |
| 3253 | |||
| 3254 |
3/4✓ Branch 0 taken 65301 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 65297 times.
|
65301 | if (reject_geometry_args(arg_count, args, this)) return true; |
| 3255 | |||
| 3256 |
4/6✓ Branch 0 taken 65297 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 64620 times.
✓ Branch 3 taken 87 times.
✓ Branch 4 taken 590 times.
✗ Branch 5 not taken.
|
65297 | switch (args[0]->result_type()) { |
| 3257 | 64620 | case STRING_RESULT: | |
| 3258 | case REAL_RESULT: | ||
| 3259 |
1/2✓ Branch 0 taken 64620 times.
✗ Branch 1 not taken.
|
64620 | set_data_type_double(); |
| 3260 | 64620 | hybrid_type = REAL_RESULT; | |
| 3261 | 64620 | break; | |
| 3262 | 87 | case INT_RESULT: | |
| 3263 |
1/2✓ Branch 0 taken 87 times.
✗ Branch 1 not taken.
|
87 | set_data_type_longlong(); |
| 3264 | 87 | unsigned_flag = args[0]->unsigned_flag; | |
| 3265 | 87 | hybrid_type = INT_RESULT; | |
| 3266 | 87 | break; | |
| 3267 | 590 | case DECIMAL_RESULT: { | |
| 3268 | // For historical reasons, CEILING and FLOOR convert DECIMAL inputs into | ||
| 3269 | // BIGINT (granted that they are small enough to fit) while ROUND and | ||
| 3270 | // TRUNCATE don't. As items are not yet evaluated at this point, | ||
| 3271 | // assumptions must be made about when a conversion from DECIMAL_RESULT to | ||
| 3272 | // INT_RESULT can be safely achieved. | ||
| 3273 | // | ||
| 3274 | // During the rounding operation, we account for signedness by always | ||
| 3275 | // assuming that the argument DECIMAL is signed. Additionally, since we | ||
| 3276 | // call set_data_type_decimal with a scale of 0, we must increment the | ||
| 3277 | // precision here, as the rounding operation may cause an increase in | ||
| 3278 | // order of magnitude. | ||
| 3279 |
1/2✓ Branch 0 taken 590 times.
✗ Branch 1 not taken.
|
590 | int precision = args[0]->decimal_precision() - args[0]->decimals; |
| 3280 |
2/2✓ Branch 0 taken 572 times.
✓ Branch 1 taken 18 times.
|
590 | if (args[0]->decimals != 0) ++precision; |
| 3281 |
1/2✓ Branch 0 taken 590 times.
✗ Branch 1 not taken.
|
590 | set_data_type_decimal(precision, 0); |
| 3282 | 590 | hybrid_type = DECIMAL_RESULT; | |
| 3283 | |||
| 3284 | // The max_length of the biggest INT_RESULT, BIGINT, is 20 regardless of | ||
| 3285 | // signedness, as a minus sign will be counted as one digit. A DECIMAL of | ||
| 3286 | // length 20 could be bigger than the max BIGINT value, thus requiring a | ||
| 3287 | // length < 20. DECIMAL_LONGLONG_DIGITS value is 22, which is presumably | ||
| 3288 | // the sum of 20 digits, a minus sign and a decimal point; requiring -2 | ||
| 3289 | // when considering the conversion. | ||
| 3290 |
2/2✓ Branch 0 taken 538 times.
✓ Branch 1 taken 52 times.
|
590 | if (max_length < (DECIMAL_LONGLONG_DIGITS - 2)) { |
| 3291 |
1/2✓ Branch 0 taken 538 times.
✗ Branch 1 not taken.
|
538 | set_data_type_longlong(); |
| 3292 | 538 | hybrid_type = INT_RESULT; | |
| 3293 | } | ||
| 3294 | |||
| 3295 | 590 | break; | |
| 3296 | } | ||
| 3297 | ✗ | default: | |
| 3298 | ✗ | assert(0); | |
| 3299 | } | ||
| 3300 |
3/14✓ Branch 0 taken 65297 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 65297 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 65297 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
65297 | DBUG_PRINT("info", ("Type: %s", (hybrid_type == REAL_RESULT |
| 3301 | ? "REAL_RESULT" | ||
| 3302 | : hybrid_type == DECIMAL_RESULT | ||
| 3303 | ? "DECIMAL_RESULT" | ||
| 3304 | : hybrid_type == INT_RESULT | ||
| 3305 | ? "INT_RESULT" | ||
| 3306 | : "--ILLEGAL!!!--"))); | ||
| 3307 | |||
| 3308 | 65297 | return false; | |
| 3309 | 65301 | } | |
| 3310 | |||
| 3311 | 293 | longlong Item_func_ceiling::int_op() { | |
| 3312 | longlong result; | ||
| 3313 |
3/5✓ Branch 0 taken 293 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 280 times.
✗ Branch 4 not taken.
|
293 | switch (args[0]->result_type()) { |
| 3314 | 13 | case INT_RESULT: | |
| 3315 |
1/2✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
|
13 | result = args[0]->val_int(); |
| 3316 | 13 | null_value = args[0]->null_value; | |
| 3317 | 13 | break; | |
| 3318 | 280 | case DECIMAL_RESULT: { | |
| 3319 | 280 | my_decimal dec_buf, *dec; | |
| 3320 |
2/4✓ Branch 0 taken 280 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 280 times.
✗ Branch 3 not taken.
|
280 | if ((dec = Item_func_ceiling::decimal_op(&dec_buf))) |
| 3321 |
1/2✓ Branch 0 taken 280 times.
✗ Branch 1 not taken.
|
280 | my_decimal2int(E_DEC_FATAL_ERROR, dec, unsigned_flag, &result); |
| 3322 | else | ||
| 3323 | ✗ | result = 0; | |
| 3324 | 280 | break; | |
| 3325 | 280 | } | |
| 3326 | ✗ | default: | |
| 3327 | ✗ | result = (longlong)Item_func_ceiling::real_op(); | |
| 3328 | }; | ||
| 3329 | 293 | return result; | |
| 3330 | } | ||
| 3331 | |||
| 3332 | 12 | double Item_func_ceiling::real_op() { | |
| 3333 | 12 | double value = args[0]->val_real(); | |
| 3334 | 12 | null_value = args[0]->null_value; | |
| 3335 | 12 | return ceil(value); | |
| 3336 | } | ||
| 3337 | |||
| 3338 | 286 | my_decimal *Item_func_ceiling::decimal_op(my_decimal *decimal_value) { | |
| 3339 |
1/2✓ Branch 0 taken 286 times.
✗ Branch 1 not taken.
|
286 | my_decimal val, *value = args[0]->val_decimal(&val); |
| 3340 |
1/2✓ Branch 0 taken 286 times.
✗ Branch 1 not taken.
|
286 | if (!(null_value = |
| 3341 |
1/2✓ Branch 0 taken 286 times.
✗ Branch 1 not taken.
|
572 | (args[0]->null_value || |
| 3342 |
2/4✓ Branch 0 taken 286 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 286 times.
|
286 | my_decimal_ceiling(E_DEC_FATAL_ERROR, value, decimal_value) > 1))) |
| 3343 | 286 | return decimal_value; | |
| 3344 | ✗ | return nullptr; | |
| 3345 | 286 | } | |
| 3346 | |||
| 3347 | 38483 | longlong Item_func_floor::int_op() { | |
| 3348 | longlong result; | ||
| 3349 |
3/5✓ Branch 0 taken 38483 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 35 times.
✓ Branch 3 taken 38448 times.
✗ Branch 4 not taken.
|
38483 | switch (args[0]->result_type()) { |
| 3350 | 35 | case INT_RESULT: | |
| 3351 |
1/2✓ Branch 0 taken 35 times.
✗ Branch 1 not taken.
|
35 | result = args[0]->val_int(); |
| 3352 | 35 | null_value = args[0]->null_value; | |
| 3353 | 35 | break; | |
| 3354 | 38448 | case DECIMAL_RESULT: { | |
| 3355 | 38448 | my_decimal dec_buf, *dec; | |
| 3356 |
2/4✓ Branch 0 taken 38448 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 38448 times.
✗ Branch 3 not taken.
|
38448 | if ((dec = Item_func_floor::decimal_op(&dec_buf))) |
| 3357 |
1/2✓ Branch 0 taken 38448 times.
✗ Branch 1 not taken.
|
38448 | my_decimal2int(E_DEC_FATAL_ERROR, dec, unsigned_flag, &result); |
| 3358 | else | ||
| 3359 | ✗ | result = 0; | |
| 3360 | 38448 | break; | |
| 3361 | 38448 | } | |
| 3362 | ✗ | default: | |
| 3363 | ✗ | result = (longlong)Item_func_floor::real_op(); | |
| 3364 | }; | ||
| 3365 | 38483 | return result; | |
| 3366 | } | ||
| 3367 | |||
| 3368 | 689271 | double Item_func_floor::real_op() { | |
| 3369 | 689271 | double value = args[0]->val_real(); | |
| 3370 | 689272 | null_value = args[0]->null_value; | |
| 3371 | 689272 | return floor(value); | |
| 3372 | } | ||
| 3373 | |||
| 3374 | 412676 | my_decimal *Item_func_floor::decimal_op(my_decimal *decimal_value) { | |
| 3375 |
1/2✓ Branch 0 taken 412676 times.
✗ Branch 1 not taken.
|
412676 | my_decimal val, *value = args[0]->val_decimal(&val); |
| 3376 |
1/2✓ Branch 0 taken 412676 times.
✗ Branch 1 not taken.
|
412676 | if (!(null_value = |
| 3377 |
1/2✓ Branch 0 taken 412676 times.
✗ Branch 1 not taken.
|
825352 | (args[0]->null_value || |
| 3378 |
2/4✓ Branch 0 taken 412676 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 412676 times.
|
412676 | my_decimal_floor(E_DEC_FATAL_ERROR, value, decimal_value) > 1))) |
| 3379 | 412676 | return decimal_value; | |
| 3380 | ✗ | return nullptr; | |
| 3381 | 412676 | } | |
| 3382 | |||
| 3383 | 73606 | bool Item_func_round::resolve_type(THD *thd) { | |
| 3384 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73606 times.
|
73606 | if (param_type_is_default(thd, 0, 1, MYSQL_TYPE_NEWDECIMAL)) return true; |
| 3385 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73606 times.
|
73606 | if (param_type_is_default(thd, 1, 2, MYSQL_TYPE_LONGLONG)) return true; |
| 3386 | |||
| 3387 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 73604 times.
|
73606 | if (reject_geometry_args(arg_count, args, this)) return true; |
| 3388 | |||
| 3389 |
3/4✓ Branch 0 taken 34 times.
✓ Branch 1 taken 63314 times.
✓ Branch 2 taken 10256 times.
✗ Branch 3 not taken.
|
73604 | switch (args[0]->result_type()) { |
| 3390 | 34 | case INT_RESULT: | |
| 3391 | 34 | set_data_type_longlong(); | |
| 3392 | 34 | unsigned_flag = args[0]->unsigned_flag; | |
| 3393 | 34 | hybrid_type = INT_RESULT; | |
| 3394 | 34 | break; | |
| 3395 | 63314 | case DECIMAL_RESULT: { | |
| 3396 | /* | ||
| 3397 | If the rounding precision is known at this stage (constant), use it | ||
| 3398 | to adjust the precision and scale of the result to the minimal | ||
| 3399 | values that will accommodate the answer. Otherwise, use the precision | ||
| 3400 | and scale from the first argument. | ||
| 3401 | If wanted scale is less than argument's scale, reduce it accordingly. | ||
| 3402 | When rounding, make sure to accommodate one extra digit in precision | ||
| 3403 | Example: ROUND(99.999, 2). Here, the type of the argument is | ||
| 3404 | DECIMAL(5, 3). The type of the result is DECIMAL(5,2), since the | ||
| 3405 | result of this operation is 100.00. | ||
| 3406 | Also make sure that precision is greater than zero. | ||
| 3407 | */ | ||
| 3408 | longlong val1; | ||
| 3409 |
5/6✓ Branch 0 taken 63290 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 63290 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 63290 times.
✓ Branch 5 taken 24 times.
|
63314 | if (args[1]->const_item() && args[1]->may_eval_const_item(thd)) { |
| 3410 | 63290 | val1 = args[1]->val_int(); | |
| 3411 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 63287 times.
|
63290 | if ((null_value = args[1]->is_null())) { |
| 3412 | 3 | val1 = 0; | |
| 3413 | } | ||
| 3414 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 63286 times.
|
63290 | if (args[1]->unsigned_flag) { |
| 3415 |
2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
4 | if (val1 > DECIMAL_MAX_SCALE || val1 < 0) val1 = DECIMAL_MAX_SCALE; |
| 3416 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 63275 times.
|
63286 | } else if (val1 > DECIMAL_MAX_SCALE) { |
| 3417 | 11 | val1 = DECIMAL_MAX_SCALE; | |
| 3418 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 63267 times.
|
63275 | } else if (val1 < -DECIMAL_MAX_SCALE) { |
| 3419 | 8 | val1 = -DECIMAL_MAX_SCALE; | |
| 3420 | } | ||
| 3421 | } else { | ||
| 3422 | 24 | val1 = args[0]->decimals; | |
| 3423 | } | ||
| 3424 | |||
| 3425 | 63314 | uint8 precision = args[0]->decimal_precision(); | |
| 3426 | 63314 | uint8 new_scale = args[0]->decimals; | |
| 3427 |
2/2✓ Branch 0 taken 53842 times.
✓ Branch 1 taken 9472 times.
|
63314 | if (val1 <= 0) { |
| 3428 | 53842 | precision -= new_scale; | |
| 3429 |
2/2✓ Branch 0 taken 53809 times.
✓ Branch 1 taken 33 times.
|
53842 | if (!truncate) precision += 1; |
| 3430 | 53842 | new_scale = 0; | |
| 3431 |
2/2✓ Branch 0 taken 4820 times.
✓ Branch 1 taken 4652 times.
|
9472 | } else if (val1 < new_scale) { |
| 3432 | 4820 | precision -= (new_scale - val1); | |
| 3433 |
2/2✓ Branch 0 taken 4804 times.
✓ Branch 1 taken 16 times.
|
4820 | if (!truncate) precision += 1; |
| 3434 | 4820 | new_scale = val1; | |
| 3435 | } | ||
| 3436 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 63312 times.
|
63314 | if (precision == 0) precision = 1; |
| 3437 | 63314 | set_data_type_decimal(precision, new_scale); | |
| 3438 | 63314 | hybrid_type = DECIMAL_RESULT; | |
| 3439 | 63314 | break; | |
| 3440 | } | ||
| 3441 | 10256 | case REAL_RESULT: | |
| 3442 | case STRING_RESULT: | ||
| 3443 | 10256 | set_data_type_double(); | |
| 3444 | 10256 | hybrid_type = REAL_RESULT; | |
| 3445 | 10256 | break; | |
| 3446 | ✗ | default: | |
| 3447 | ✗ | assert(0); /* This result type isn't handled */ | |
| 3448 | } | ||
| 3449 | 73604 | return false; | |
| 3450 | } | ||
| 3451 | |||
| 3452 | 40849 | double my_double_round(double value, longlong dec, bool dec_unsigned, | |
| 3453 | bool truncate) { | ||
| 3454 |
3/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 40841 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
|
40849 | bool dec_negative = (dec < 0) && !dec_unsigned; |
| 3455 | 40849 | int log_10_size = array_elements(log_10); // 309 | |
| 3456 |
4/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 40841 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 5 times.
|
40849 | if (dec_negative && dec <= -log_10_size) return 0.0; |
| 3457 | |||
| 3458 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 40841 times.
|
40846 | ulonglong abs_dec = dec_negative ? -dec : dec; |
| 3459 | |||
| 3460 |
2/2✓ Branch 0 taken 24298 times.
✓ Branch 1 taken 16548 times.
|
40846 | double tmp = (abs_dec < array_elements(log_10) ? log_10[abs_dec] |
| 3461 | 16548 | : pow(10.0, (double)abs_dec)); | |
| 3462 | |||
| 3463 | 40846 | double value_mul_tmp = value * tmp; | |
| 3464 |
6/6✓ Branch 0 taken 40841 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 16559 times.
✓ Branch 3 taken 24282 times.
✓ Branch 4 taken 16559 times.
✓ Branch 5 taken 24287 times.
|
40846 | if (!dec_negative && !std::isfinite(value_mul_tmp)) return value; |
| 3465 | |||
| 3466 | 24287 | double value_div_tmp = value / tmp; | |
| 3467 |
2/2✓ Branch 0 taken 64 times.
✓ Branch 1 taken 24223 times.
|
24287 | if (truncate) { |
| 3468 |
1/2✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
|
64 | if (value >= 0.0) |
| 3469 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 63 times.
|
64 | return dec < 0 ? floor(value_div_tmp) * tmp : floor(value_mul_tmp) / tmp; |
| 3470 | else | ||
| 3471 | ✗ | return dec < 0 ? ceil(value_div_tmp) * tmp : ceil(value_mul_tmp) / tmp; | |
| 3472 | } | ||
| 3473 | |||
| 3474 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 24219 times.
|
24223 | return dec < 0 ? rint(value_div_tmp) * tmp : rint(value_mul_tmp) / tmp; |
| 3475 | } | ||
| 3476 | |||
| 3477 | 23095 | double Item_func_round::real_op() { | |
| 3478 | 23095 | const double value = args[0]->val_real(); | |
| 3479 | 23095 | const longlong decimal_places = args[1]->val_int(); | |
| 3480 | |||
| 3481 |
6/6✓ Branch 0 taken 23094 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 23092 times.
✓ Branch 4 taken 23092 times.
✓ Branch 5 taken 3 times.
|
23095 | if (!(null_value = args[0]->null_value || args[1]->null_value)) |
| 3482 | 46184 | return my_double_round(value, decimal_places, args[1]->unsigned_flag, | |
| 3483 | 23092 | truncate); | |
| 3484 | |||
| 3485 | 3 | return 0.0; | |
| 3486 | } | ||
| 3487 | |||
| 3488 | /* | ||
| 3489 | Rounds a given value to a power of 10 specified as the 'to' argument. | ||
| 3490 | */ | ||
| 3491 | 123 | static inline ulonglong my_unsigned_round(ulonglong value, ulonglong to, | |
| 3492 | bool *round_overflow) { | ||
| 3493 | 123 | ulonglong tmp = value / to * to; | |
| 3494 |
2/2✓ Branch 0 taken 68 times.
✓ Branch 1 taken 55 times.
|
123 | if (value - tmp < (to >> 1)) { |
| 3495 | 68 | return tmp; | |
| 3496 | } else { | ||
| 3497 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 46 times.
|
55 | if (test_if_sum_overflows_ull(tmp, to)) { |
| 3498 | 9 | *round_overflow = true; | |
| 3499 | 9 | return 0; | |
| 3500 | } | ||
| 3501 | 46 | return tmp + to; | |
| 3502 | } | ||
| 3503 | } | ||
| 3504 | |||
| 3505 | 178 | longlong Item_func_round::int_op() { | |
| 3506 | 178 | longlong value = args[0]->val_int(); | |
| 3507 | 178 | longlong dec = args[1]->val_int(); | |
| 3508 | 178 | decimals = 0; | |
| 3509 | ulonglong abs_dec; | ||
| 3510 |
3/6✓ Branch 0 taken 178 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 178 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 178 times.
|
178 | if ((null_value = args[0]->null_value || args[1]->null_value)) return 0; |
| 3511 |
4/4✓ Branch 0 taken 162 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 158 times.
|
178 | if ((dec >= 0) || args[1]->unsigned_flag) |
| 3512 | 20 | return value; // integer have not digits after point | |
| 3513 | |||
| 3514 | MY_COMPILER_DIAGNOSTIC_PUSH() | ||
| 3515 | // Suppress warning C4146 unary minus operator applied to unsigned type, | ||
| 3516 | // result still unsigned | ||
| 3517 | MY_COMPILER_MSVC_DIAGNOSTIC_IGNORE(4146) | ||
| 3518 | 158 | abs_dec = -static_cast<ulonglong>(dec); | |
| 3519 | MY_COMPILER_DIAGNOSTIC_POP() | ||
| 3520 | longlong tmp; | ||
| 3521 | |||
| 3522 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 148 times.
|
158 | if (abs_dec >= array_elements(log_10_int)) return 0; |
| 3523 | |||
| 3524 | 148 | tmp = log_10_int[abs_dec]; | |
| 3525 | |||
| 3526 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 143 times.
|
148 | if (truncate) |
| 3527 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
|
5 | return (unsigned_flag) ? ((ulonglong)value / tmp) * tmp |
| 3528 | 5 | : (value / tmp) * tmp; | |
| 3529 |
4/4✓ Branch 0 taken 83 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 24 times.
✓ Branch 3 taken 59 times.
|
143 | else if (unsigned_flag || value >= 0) { |
| 3530 | 84 | bool round_overflow = false; | |
| 3531 | ulonglong rounded_value = | ||
| 3532 | 84 | my_unsigned_round(static_cast<ulonglong>(value), tmp, &round_overflow); | |
| 3533 |
4/4✓ Branch 0 taken 24 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 14 times.
|
84 | if (!unsigned_flag && rounded_value > LLONG_MAX) |
| 3534 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | return raise_integer_overflow(); |
| 3535 |
3/4✓ Branch 0 taken 9 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
|
74 | if (round_overflow) return raise_integer_overflow(); |
| 3536 | 65 | return rounded_value; | |
| 3537 | } else { | ||
| 3538 | // We round "towards nearest", so | ||
| 3539 | // -9223372036854775808 should round to | ||
| 3540 | // -9223372036854775810 which underflows, or | ||
| 3541 | // -9223372036854775800 which is OK, or | ||
| 3542 | // -9223372036854776000 which underflows, and so on ... | ||
| 3543 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 39 times.
|
59 | if (value == LLONG_MIN) { |
| 3544 |
2/3✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 9 times.
|
20 | switch (abs_dec) { |
| 3545 | ✗ | case 0: | |
| 3546 | ✗ | return LLONG_MIN; | |
| 3547 | 11 | case 1: | |
| 3548 | case 3: | ||
| 3549 | case 4: | ||
| 3550 | case 5: | ||
| 3551 | case 6: | ||
| 3552 | case 8: | ||
| 3553 | case 9: | ||
| 3554 | case 10: | ||
| 3555 | case 14: | ||
| 3556 | case 19: | ||
| 3557 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | return raise_integer_overflow(); |
| 3558 | 9 | default: | |
| 3559 | 9 | return (LLONG_MIN / tmp) * tmp; | |
| 3560 | } | ||
| 3561 | } | ||
| 3562 | 39 | bool not_used = false; | |
| 3563 | ulonglong rounded_value = | ||
| 3564 | 39 | my_unsigned_round(static_cast<ulonglong>(-value), tmp, ¬_used); | |
| 3565 |
3/4✓ Branch 0 taken 10 times.
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
|
39 | if (rounded_value > LLONG_MAX) return raise_integer_overflow(); |
| 3566 | |||
| 3567 | 29 | return -static_cast<longlong>(rounded_value); | |
| 3568 | } | ||
| 3569 | } | ||
| 3570 | |||
| 3571 | 5252 | my_decimal *Item_func_round::decimal_op(my_decimal *decimal_value) { | |
| 3572 |
1/2✓ Branch 0 taken 5252 times.
✗ Branch 1 not taken.
|
5252 | my_decimal val, *value = args[0]->val_decimal(&val); |
| 3573 |
1/2✓ Branch 0 taken 5252 times.
✗ Branch 1 not taken.
|
5252 | longlong dec = args[1]->val_int(); |
| 3574 |
4/4✓ Branch 0 taken 39 times.
✓ Branch 1 taken 5213 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 35 times.
|
5252 | if (dec >= 0 || args[1]->unsigned_flag) |
| 3575 | 5217 | dec = min<ulonglong>(dec, decimals); | |
| 3576 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 29 times.
|
35 | else if (dec < INT_MIN) |
| 3577 | 6 | dec = INT_MIN; | |
| 3578 | |||
| 3579 |
6/6✓ Branch 0 taken 4901 times.
✓ Branch 1 taken 351 times.
✓ Branch 2 taken 4900 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 4900 times.
✓ Branch 5 taken 352 times.
|
10152 | if (!(null_value = (args[0]->null_value || args[1]->null_value || |
| 3580 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4900 times.
|
4900 | my_decimal_round(E_DEC_FATAL_ERROR, value, (int)dec, |
| 3581 |
1/2✓ Branch 0 taken 4900 times.
✗ Branch 1 not taken.
|
4900 | truncate, decimal_value) > 1))) |
| 3582 | 4900 | return decimal_value; | |
| 3583 | 352 | return nullptr; | |
| 3584 | 5252 | } | |
| 3585 | |||
| 3586 | 81528 | bool Item_func_rand::itemize(Parse_context *pc, Item **res) { | |
| 3587 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 81528 times.
|
81528 | if (skip_itemize(res)) return false; |
| 3588 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 81528 times.
|
81528 | if (super::itemize(pc, res)) return true; |
| 3589 | /* | ||
| 3590 | When RAND() is binlogged, the seed is binlogged too. So the | ||
| 3591 | sequence of random numbers is the same on a replication slave as | ||
| 3592 | on the master. However, if several RAND() values are inserted | ||
| 3593 | into a table, the order in which the rows are modified may differ | ||
| 3594 | between master and slave, because the order is undefined. Hence, | ||
| 3595 | the statement is unsafe to log in statement format. | ||
| 3596 | */ | ||
| 3597 | 81528 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 3598 | |||
| 3599 | 81528 | pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_RAND); | |
| 3600 | 81528 | return false; | |
| 3601 | } | ||
| 3602 | |||
| 3603 | 4785 | void Item_func_rand::seed_random(Item *arg) { | |
| 3604 | /* | ||
| 3605 | TODO: do not do reinit 'rand' for every execute of PS/SP if | ||
| 3606 | args[0] is a constant. | ||
| 3607 | */ | ||
| 3608 | #ifdef WITH_WSREP | ||
| 3609 | uint32 tmp; | ||
| 3610 | 4785 | THD *thd = current_thd; | |
| 3611 |
2/8✓ Branch 0 taken 4785 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4785 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
4785 | if (WSREP(thd)) { |
| 3612 | /* This ensures same random value is assigned to replicated transaction. */ | ||
| 3613 | ✗ | if (wsrep_thd_is_applying(thd)) | |
| 3614 | ✗ | tmp = thd->wsrep_rand; | |
| 3615 | else | ||
| 3616 | ✗ | tmp = thd->wsrep_rand = (uint32)arg->val_int(); | |
| 3617 | } else { | ||
| 3618 | 4785 | tmp = (uint32)arg->val_int(); | |
| 3619 | } | ||
| 3620 | #else | ||
| 3621 | uint32 tmp = (uint32)arg->val_int(); | ||
| 3622 | #endif /* WITH_WSREP */ | ||
| 3623 | 4785 | randominit(m_rand, (uint32)(tmp * 0x10001L + 55555555L), | |
| 3624 | (uint32)(tmp * 0x10000001L)); | ||
| 3625 | 4785 | } | |
| 3626 | |||
| 3627 | 80949 | bool Item_func_rand::resolve_type(THD *thd) { | |
| 3628 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 80950 times.
|
80949 | if (param_type_is_default(thd, 0, -1, MYSQL_TYPE_DOUBLE)) return true; |
| 3629 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 80949 times.
|
80950 | if (Item_real_func::resolve_type(thd)) return true; |
| 3630 | 80949 | return reject_geometry_args(arg_count, args, this); | |
| 3631 | } | ||
| 3632 | |||
| 3633 | 80949 | bool Item_func_rand::fix_fields(THD *thd, Item **ref) { | |
| 3634 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 80949 times.
|
80949 | if (Item_real_func::fix_fields(thd, ref)) return true; |
| 3635 | |||
| 3636 |
2/2✓ Branch 0 taken 4786 times.
✓ Branch 1 taken 76163 times.
|
80949 | if (arg_count > 0) { // Only use argument once in query |
| 3637 | /* | ||
| 3638 | Allocate rand structure once: we must use thd->stmt_arena | ||
| 3639 | to create rand in proper mem_root if it's a prepared statement or | ||
| 3640 | stored procedure. | ||
| 3641 | |||
| 3642 | No need to send a Rand log event if seed was given eg: RAND(seed), | ||
| 3643 | as it will be replicated in the query as such. | ||
| 3644 | */ | ||
| 3645 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4786 times.
|
4786 | assert(m_rand == nullptr); |
| 3646 | 4786 | m_rand = pointer_cast<rand_struct *>(thd->alloc(sizeof(*m_rand))); | |
| 3647 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4786 times.
|
4786 | if (m_rand == nullptr) return true; |
| 3648 | } else { | ||
| 3649 | /* | ||
| 3650 | Save the seed only the first time RAND() is used in the query | ||
| 3651 | Once events are forwarded rather than recreated, | ||
| 3652 | the following can be skipped if inside the slave thread | ||
| 3653 | */ | ||
| 3654 |
2/2✓ Branch 0 taken 69543 times.
✓ Branch 1 taken 6620 times.
|
76163 | if (!thd->rand_used) { |
| 3655 | 69543 | thd->rand_used = true; | |
| 3656 | 69543 | thd->rand_saved_seed1 = thd->rand.seed1; | |
| 3657 | 69543 | thd->rand_saved_seed2 = thd->rand.seed2; | |
| 3658 | } | ||
| 3659 | } | ||
| 3660 | 80949 | return false; | |
| 3661 | } | ||
| 3662 | |||
| 3663 | 4546849 | double Item_func_rand::val_real() { | |
| 3664 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4546849 times.
|
4546849 | assert(fixed); |
| 3665 | rand_struct *rand; | ||
| 3666 |
2/2✓ Branch 0 taken 495962 times.
✓ Branch 1 taken 4050887 times.
|
4546849 | if (arg_count > 0) { |
| 3667 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 495946 times.
|
495962 | if (!args[0]->const_for_execution()) |
| 3668 | 16 | seed_random(args[0]); | |
| 3669 |
2/2✓ Branch 0 taken 4769 times.
✓ Branch 1 taken 491177 times.
|
495946 | else if (first_eval) { |
| 3670 | /* | ||
| 3671 | Constantness of args[0] may be set during JOIN::optimize(), if arg[0] | ||
| 3672 | is a field item of "constant" table. Thus, we have to evaluate | ||
| 3673 | seed_random() for constant arg there but not at the fix_fields method. | ||
| 3674 | */ | ||
| 3675 | 4769 | first_eval = false; | |
| 3676 | 4769 | seed_random(args[0]); | |
| 3677 | } | ||
| 3678 | 495962 | rand = m_rand; | |
| 3679 | } else { | ||
| 3680 | /* | ||
| 3681 | Save the seed only the first time RAND() is used in the query | ||
| 3682 | Once events are forwarded rather than recreated, | ||
| 3683 | the following can be skipped if inside the slave thread | ||
| 3684 | */ | ||
| 3685 | 4050887 | THD *const thd = current_thd; | |
| 3686 |
2/2✓ Branch 0 taken 89312 times.
✓ Branch 1 taken 3961700 times.
|
4051012 | if (!thd->rand_used) { |
| 3687 | 89312 | thd->rand_used = true; | |
| 3688 | 89312 | thd->rand_saved_seed1 = thd->rand.seed1; | |
| 3689 | 89312 | thd->rand_saved_seed2 = thd->rand.seed2; | |
| 3690 | } | ||
| 3691 | 4051012 | rand = &thd->rand; | |
| 3692 | } | ||
| 3693 | 4546974 | return my_rnd(rand); | |
| 3694 | } | ||
| 3695 | |||
| 3696 | 27 | bool Item_func_sign::resolve_type(THD *thd) { | |
| 3697 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
|
27 | if (param_type_is_default(thd, 0, 1, MYSQL_TYPE_DOUBLE)) return true; |
| 3698 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
|
27 | if (Item_int_func::resolve_type(thd)) return true; |
| 3699 | 27 | return reject_geometry_args(arg_count, args, this); | |
| 3700 | } | ||
| 3701 | |||
| 3702 | 34 | longlong Item_func_sign::val_int() { | |
| 3703 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | assert(fixed == 1); |
| 3704 | 34 | double value = args[0]->val_real(); | |
| 3705 | 34 | null_value = args[0]->null_value; | |
| 3706 |
4/4✓ Branch 0 taken 9 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 6 times.
|
34 | return value < 0.0 ? -1 : (value > 0 ? 1 : 0); |
| 3707 | } | ||
| 3708 | |||
| 3709 | 40 | bool Item_func_units::resolve_type(THD *thd) { | |
| 3710 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
|
40 | if (param_type_is_default(thd, 0, 1, MYSQL_TYPE_DOUBLE)) return true; |
| 3711 | 40 | decimals = DECIMAL_NOT_SPECIFIED; | |
| 3712 | 40 | max_length = float_length(decimals); | |
| 3713 | 40 | return reject_geometry_args(arg_count, args, this); | |
| 3714 | } | ||
| 3715 | |||
| 3716 | 37 | double Item_func_units::val_real() { | |
| 3717 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
|
37 | assert(fixed == 1); |
| 3718 | 37 | double value = args[0]->val_real(); | |
| 3719 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
|
37 | if ((null_value = args[0]->null_value)) return 0; |
| 3720 | 37 | return check_float_overflow(value * mul + add); | |
| 3721 | } | ||
| 3722 | |||
| 3723 | 3777 | bool Item_func_min_max::resolve_type(THD *thd) { | |
| 3724 | // If no arguments have type, type of this operator cannot be determined yet | ||
| 3725 |
5/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3771 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 3771 times.
|
3783 | if (args[0]->data_type() == MYSQL_TYPE_INVALID && |
| 3726 | 6 | args[1]->data_type() == MYSQL_TYPE_INVALID) | |
| 3727 | 6 | return false; | |
| 3728 | |||
| 3729 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3770 times.
|
3771 | if (resolve_type_inner(thd)) return true; |
| 3730 | 3770 | return reject_geometry_args(arg_count, args, this); | |
| 3731 | } | ||
| 3732 | |||
| 3733 | 3777 | bool Item_func_min_max::resolve_type_inner(THD *thd) { | |
| 3734 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3777 times.
|
3777 | if (param_type_uses_non_param(thd)) return true; |
| 3735 | 3777 | aggregate_type(make_array(args, arg_count)); | |
| 3736 | 3777 | hybrid_type = Field::result_merge_type(data_type()); | |
| 3737 |
2/2✓ Branch 0 taken 231 times.
✓ Branch 1 taken 3546 times.
|
3777 | if (hybrid_type == STRING_RESULT) { |
| 3738 | /* | ||
| 3739 | If one or more of the arguments have a temporal data type, temporal_item | ||
| 3740 | must be set for correct conversion from temporal values to various result | ||
| 3741 | types. | ||
| 3742 | */ | ||
| 3743 |
2/2✓ Branch 0 taken 508 times.
✓ Branch 1 taken 231 times.
|
739 | for (uint i = 0; i < arg_count; i++) { |
| 3744 |
2/2✓ Branch 0 taken 241 times.
✓ Branch 1 taken 267 times.
|
508 | if (args[i]->is_temporal()) { |
| 3745 | /* | ||
| 3746 | If one of the arguments is DATETIME, overwrite any existing | ||
| 3747 | temporal_item since DATETIME contains both date and time and is the | ||
| 3748 | most general and detailed data type to which other temporal types can | ||
| 3749 | be converted without loss of information. | ||
| 3750 | */ | ||
| 3751 |
6/6✓ Branch 0 taken 73 times.
✓ Branch 1 taken 168 times.
✓ Branch 2 taken 26 times.
✓ Branch 3 taken 47 times.
✓ Branch 4 taken 194 times.
✓ Branch 5 taken 47 times.
|
241 | if (!temporal_item || args[i]->data_type() == MYSQL_TYPE_DATETIME) |
| 3752 | 194 | temporal_item = args[i]; | |
| 3753 | } | ||
| 3754 | } | ||
| 3755 | /* | ||
| 3756 | If one or more, but not all, of the arguments have a temporal data type, | ||
| 3757 | the data type of this item must be set temporarily to ensure that the | ||
| 3758 | various aggregate functions derive the correct properties. | ||
| 3759 | */ | ||
| 3760 |
2/2✓ Branch 0 taken 103 times.
✓ Branch 1 taken 63 times.
|
397 | enum_field_types tmp_data_type = (!is_temporal() && has_temporal_arg()) |
| 3761 |
2/2✓ Branch 0 taken 166 times.
✓ Branch 1 taken 65 times.
|
334 | ? temporal_item->data_type() |
| 3762 | 128 | : data_type(); | |
| 3763 | 231 | enum_field_types aggregated_data_type = data_type(); | |
| 3764 | 231 | set_data_type(tmp_data_type); | |
| 3765 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 230 times.
|
231 | if (aggregate_string_properties(func_name(), args, arg_count)) return true; |
| 3766 | 230 | set_data_type(aggregated_data_type); | |
| 3767 | } else | ||
| 3768 | 3546 | aggregate_num_type(hybrid_type, args, arg_count); | |
| 3769 | |||
| 3770 | /* | ||
| 3771 | LEAST and GREATEST convert JSON values to strings before they are | ||
| 3772 | compared, so their JSON nature is lost. Raise a warning to | ||
| 3773 | indicate to the users that the values are not compared using the | ||
| 3774 | JSON comparator, as they might expect. Also update the field type | ||
| 3775 | of the result to reflect that the result is a string. | ||
| 3776 | */ | ||
| 3777 | 3776 | unsupported_json_comparison(arg_count, args, | |
| 3778 | "comparison of JSON in the " | ||
| 3779 | "LEAST and GREATEST operators"); | ||
| 3780 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 3772 times.
|
3776 | if (data_type() == MYSQL_TYPE_JSON) set_data_type(MYSQL_TYPE_VARCHAR); |
| 3781 | 3776 | return false; | |
| 3782 | } | ||
| 3783 | |||
| 3784 | 209 | bool Item_func_min_max::cmp_datetimes(longlong *value) { | |
| 3785 | 209 | THD *thd = current_thd; | |
| 3786 | 209 | longlong res = 0; | |
| 3787 |
2/2✓ Branch 0 taken 430 times.
✓ Branch 1 taken 192 times.
|
622 | for (uint i = 0; i < arg_count; i++) { |
| 3788 | 430 | Item **arg = args + i; | |
| 3789 | bool is_null; | ||
| 3790 | longlong tmp = | ||
| 3791 |
1/2✓ Branch 0 taken 430 times.
✗ Branch 1 not taken.
|
430 | get_datetime_value(thd, &arg, nullptr, temporal_item, &is_null); |
| 3792 | |||
| 3793 | // Check if we need to stop (because of error or KILL) and stop the loop | ||
| 3794 |
3/4✓ Branch 0 taken 430 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 429 times.
|
446 | if ((null_value = thd->is_error())) return true; |
| 3795 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 413 times.
|
429 | if ((null_value = args[i]->null_value)) return true; |
| 3796 |
4/4✓ Branch 0 taken 221 times.
✓ Branch 1 taken 192 times.
✓ Branch 2 taken 89 times.
✓ Branch 3 taken 132 times.
|
413 | if (i == 0 || (tmp < res) == m_is_least_func) res = tmp; |
| 3797 | } | ||
| 3798 | 192 | *value = res; | |
| 3799 | 192 | return false; | |
| 3800 | } | ||
| 3801 | |||
| 3802 | 10 | bool Item_func_min_max::cmp_times(longlong *value) { | |
| 3803 | 10 | longlong res = 0; | |
| 3804 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 8 times.
|
28 | for (uint i = 0; i < arg_count; i++) { |
| 3805 | 20 | longlong tmp = args[i]->val_time_temporal(); | |
| 3806 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 18 times.
|
20 | if ((null_value = args[i]->null_value)) return true; |
| 3807 |
4/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 4 times.
|
18 | if (i == 0 || (tmp < res) == m_is_least_func) res = tmp; |
| 3808 | } | ||
| 3809 | 8 | *value = res; | |
| 3810 | 8 | return false; | |
| 3811 | } | ||
| 3812 | |||
| 3813 | 179 | String *Item_func_min_max::str_op(String *str) { | |
| 3814 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 179 times.
|
179 | assert(fixed); |
| 3815 | 179 | null_value = false; | |
| 3816 |
2/2✓ Branch 0 taken 100 times.
✓ Branch 1 taken 79 times.
|
179 | if (compare_as_dates()) { |
| 3817 | 100 | longlong result = 0; | |
| 3818 |
4/6✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 89 times.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
|
180 | if (cmp_datetimes(&result)) return error_str(); |
| 3819 | |||
| 3820 | /* | ||
| 3821 | If result is greater than 0, the winning argument was successfully | ||
| 3822 | converted to a time value and should be converted to a string | ||
| 3823 | formatted in accordance with the data type in temporal_item. Otherwise, | ||
| 3824 | the arguments should be compared based on their raw string value. | ||
| 3825 | */ | ||
| 3826 |
2/2✓ Branch 0 taken 80 times.
✓ Branch 1 taken 9 times.
|
89 | if (result > 0) { |
| 3827 | MYSQL_TIME ltime; | ||
| 3828 | 80 | enum_field_types field_type = temporal_item->data_type(); | |
| 3829 |
1/2✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
|
80 | TIME_from_longlong_packed(<ime, field_type, result); |
| 3830 |
1/2✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
|
80 | null_value = my_TIME_to_str(<ime, str, decimals); |
| 3831 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
|
80 | if (null_value) return nullptr; |
| 3832 |
3/4✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29 times.
✓ Branch 3 taken 51 times.
|
80 | if (str->needs_conversion(collation.collation)) { |
| 3833 | 29 | uint errors = 0; | |
| 3834 | 29 | StringBuffer<STRING_BUFFER_USUAL_SIZE * 2> convert_string(nullptr); | |
| 3835 | bool copy_failed = | ||
| 3836 |
1/2✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
|
29 | convert_string.copy(str->ptr(), str->length(), str->charset(), |
| 3837 | collation.collation, &errors); | ||
| 3838 |
5/10✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 29 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 29 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 29 times.
|
29 | if (copy_failed || errors || str->copy(convert_string)) |
| 3839 | ✗ | return error_str(); | |
| 3840 |
1/2✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
|
29 | } |
| 3841 | 80 | return str; | |
| 3842 | } | ||
| 3843 | } | ||
| 3844 | |||
| 3845 | // Find the least/greatest argument based on string value. | ||
| 3846 | 88 | String *res = nullptr; | |
| 3847 | 88 | bool res_in_str = false; | |
| 3848 |
2/2✓ Branch 0 taken 181 times.
✓ Branch 1 taken 73 times.
|
254 | for (uint i = 0; i < arg_count; i++) { |
| 3849 | /* | ||
| 3850 | Because val_str() may reallocate the underlying buffer of its String | ||
| 3851 | parameter, it is paramount the passed String argument do not share an | ||
| 3852 | underlying buffer with the currently stored result against which it will | ||
| 3853 | be compared to ensure that String comparison operates on two | ||
| 3854 | non-overlapping buffers. | ||
| 3855 | */ | ||
| 3856 |
2/2✓ Branch 0 taken 85 times.
✓ Branch 1 taken 96 times.
|
181 | String *val_buf = res_in_str ? &m_string_buf : str; |
| 3857 |
4/6✓ Branch 0 taken 93 times.
✓ Branch 1 taken 88 times.
✓ Branch 2 taken 93 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 93 times.
✗ Branch 5 not taken.
|
181 | assert(!res || (res != val_buf && !res->uses_buffer_owned_by(val_buf))); |
| 3858 | 181 | String *val = args[i]->val_str(val_buf); | |
| 3859 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 166 times.
|
181 | if ((null_value = args[i]->null_value)) return nullptr; |
| 3860 |
4/4✓ Branch 0 taken 87 times.
✓ Branch 1 taken 79 times.
✓ Branch 2 taken 110 times.
✓ Branch 3 taken 56 times.
|
253 | if (i == 0 || |
| 3861 |
2/2✓ Branch 0 taken 31 times.
✓ Branch 1 taken 56 times.
|
87 | (sortcmp(val, res, collation.collation) < 0) == m_is_least_func) { |
| 3862 | 110 | res = val; | |
| 3863 | 110 | res_in_str = !res_in_str; | |
| 3864 | } | ||
| 3865 | } | ||
| 3866 | 73 | res->set_charset(collation.collation); | |
| 3867 | 73 | return res; | |
| 3868 | } | ||
| 3869 | |||
| 3870 | 85 | bool Item_func_min_max::date_op(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) { | |
| 3871 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
|
85 | assert(fixed == 1); |
| 3872 | 85 | longlong result = 0; | |
| 3873 |
3/4✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 80 times.
|
85 | if (cmp_datetimes(&result)) return true; |
| 3874 |
1/2✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
|
80 | TIME_from_longlong_packed(ltime, data_type(), result); |
| 3875 | int warnings; | ||
| 3876 |
1/2✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
|
80 | return check_date(*ltime, non_zero_date(*ltime), fuzzydate, &warnings); |
| 3877 | } | ||
| 3878 | |||
| 3879 | 10 | bool Item_func_min_max::time_op(MYSQL_TIME *ltime) { | |
| 3880 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | assert(fixed == 1); |
| 3881 | 10 | longlong result = 0; | |
| 3882 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | if (compare_as_dates()) { |
| 3883 | ✗ | if (cmp_datetimes(&result)) return true; | |
| 3884 | ✗ | TIME_from_longlong_packed(ltime, data_type(), result); | |
| 3885 | ✗ | datetime_to_time(ltime); | |
| 3886 | ✗ | return false; | |
| 3887 | } | ||
| 3888 | |||
| 3889 |
3/4✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
|
10 | if (cmp_times(&result)) return true; |
| 3890 |
1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
|
8 | TIME_from_longlong_time_packed(ltime, result); |
| 3891 | 8 | return false; | |
| 3892 | } | ||
| 3893 | |||
| 3894 | 31 | double Item_func_min_max::real_op() { | |
| 3895 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
|
31 | assert(fixed == 1); |
| 3896 | 31 | null_value = false; | |
| 3897 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 17 times.
|
31 | if (compare_as_dates()) { |
| 3898 | 14 | longlong result = 0; | |
| 3899 |
3/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 13 times.
|
14 | if (cmp_datetimes(&result)) return 0; |
| 3900 |
1/2✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
|
13 | return double_from_datetime_packed(temporal_item->data_type(), result); |
| 3901 | } | ||
| 3902 | |||
| 3903 | // Find the least/greatest argument based on double value. | ||
| 3904 | 17 | double result = 0.0; | |
| 3905 |
2/2✓ Branch 0 taken 35 times.
✓ Branch 1 taken 15 times.
|
50 | for (uint i = 0; i < arg_count; i++) { |
| 3906 | 35 | const double tmp = args[i]->val_real(); | |
| 3907 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 33 times.
|
35 | if ((null_value = args[i]->null_value)) return 0.0; |
| 3908 |
4/4✓ Branch 0 taken 16 times.
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 10 times.
|
33 | if (i == 0 || (tmp < result) == m_is_least_func) result = tmp; |
| 3909 | } | ||
| 3910 | 15 | return result; | |
| 3911 | } | ||
| 3912 | |||
| 3913 | 13627 | longlong Item_func_min_max::int_op() { | |
| 3914 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13627 times.
|
13627 | assert(fixed); |
| 3915 | 13627 | null_value = false; | |
| 3916 | 13627 | longlong res = 0; | |
| 3917 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 13622 times.
|
13627 | if (compare_as_dates()) { |
| 3918 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
|
5 | if (cmp_datetimes(&res)) return 0; |
| 3919 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | return longlong_from_datetime_packed(temporal_item->data_type(), res); |
| 3920 | } | ||
| 3921 | |||
| 3922 | // Find the least/greatest argument based on integer value. | ||
| 3923 |
2/2✓ Branch 0 taken 25825 times.
✓ Branch 1 taken 9263 times.
|
35088 | for (uint i = 0; i < arg_count; i++) { |
| 3924 |
1/2✓ Branch 0 taken 25825 times.
✗ Branch 1 not taken.
|
25825 | const longlong val = args[i]->val_int(); |
| 3925 |
2/2✓ Branch 0 taken 4359 times.
✓ Branch 1 taken 21466 times.
|
25825 | if ((null_value = args[i]->null_value)) return 0; |
| 3926 | #ifndef NDEBUG | ||
| 3927 | 21466 | Integer_value arg_val(val, args[i]->unsigned_flag); | |
| 3928 |
3/4✓ Branch 0 taken 16 times.
✓ Branch 1 taken 21450 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
|
21466 | assert(!unsigned_flag || !arg_val.is_negative()); |
| 3929 | #endif | ||
| 3930 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 21450 times.
|
21466 | const bool val_is_smaller = unsigned_flag ? static_cast<ulonglong>(val) < |
| 3931 | 16 | static_cast<ulonglong>(res) | |
| 3932 | 21450 | : val < res; | |
| 3933 |
4/4✓ Branch 0 taken 12199 times.
✓ Branch 1 taken 9267 times.
✓ Branch 2 taken 2761 times.
✓ Branch 3 taken 9438 times.
|
21466 | if (i == 0 || val_is_smaller == m_is_least_func) res = val; |
| 3934 | } | ||
| 3935 | 9263 | return res; | |
| 3936 | } | ||
| 3937 | |||
| 3938 | 34 | my_decimal *Item_func_min_max::decimal_op(my_decimal *dec) { | |
| 3939 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | assert(fixed == 1); |
| 3940 | 34 | null_value = false; | |
| 3941 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 29 times.
|
34 | if (compare_as_dates()) { |
| 3942 | 5 | longlong result = 0; | |
| 3943 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
|
5 | if (cmp_datetimes(&result)) return nullptr; |
| 3944 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | return my_decimal_from_datetime_packed(dec, temporal_item->data_type(), |
| 3945 | 5 | result); | |
| 3946 | } | ||
| 3947 | |||
| 3948 | // Find the least/greatest argument based on decimal value. | ||
| 3949 |
1/2✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
|
29 | my_decimal tmp_buf, *res = args[0]->val_decimal(dec); |
| 3950 |
2/2✓ Branch 0 taken 63 times.
✓ Branch 1 taken 28 times.
|
91 | for (uint i = 0; i < arg_count; i++) { |
| 3951 |
3/4✓ Branch 0 taken 29 times.
✓ Branch 1 taken 34 times.
✓ Branch 2 taken 63 times.
✗ Branch 3 not taken.
|
63 | my_decimal *tmp = args[i]->val_decimal(res == dec ? &tmp_buf : dec); |
| 3952 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 62 times.
|
63 | if ((null_value = args[i]->null_value)) return nullptr; |
| 3953 |
7/8✓ Branch 0 taken 33 times.
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 17 times.
✓ Branch 5 taken 16 times.
✓ Branch 6 taken 46 times.
✓ Branch 7 taken 16 times.
|
62 | if (i == 0 || (my_decimal_cmp(tmp, res) < 0) == m_is_least_func) res = tmp; |
| 3954 | } | ||
| 3955 | // Result must me copied from temporary buffer to remain valid after return. | ||
| 3956 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 17 times.
|
28 | if (res == &tmp_buf) { |
| 3957 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | my_decimal2decimal(res, dec); |
| 3958 | 11 | res = dec; | |
| 3959 | } | ||
| 3960 | 28 | return res; | |
| 3961 | 29 | } | |
| 3962 | |||
| 3963 | 37 | double Item_func_min_max::val_real() { | |
| 3964 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
|
37 | assert(fixed == 1); |
| 3965 |
6/6✓ Branch 0 taken 19 times.
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 18 times.
✓ Branch 5 taken 19 times.
|
37 | if (has_temporal_arg() && data_type() == MYSQL_TYPE_VARCHAR) |
| 3966 | 18 | return real_op(); // For correct conversion from temporal value to string. | |
| 3967 | 19 | return Item_func_numhybrid::val_real(); | |
| 3968 | } | ||
| 3969 | |||
| 3970 | 13603 | longlong Item_func_min_max::val_int() { | |
| 3971 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13603 times.
|
13603 | assert(fixed == 1); |
| 3972 |
5/6✓ Branch 0 taken 5 times.
✓ Branch 1 taken 13598 times.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 13598 times.
|
13603 | if (has_temporal_arg() && data_type() == MYSQL_TYPE_VARCHAR) |
| 3973 | 5 | return int_op(); // For correct conversion from temporal value to int. | |
| 3974 | 13598 | return Item_func_numhybrid::val_int(); | |
| 3975 | } | ||
| 3976 | |||
| 3977 | 33 | my_decimal *Item_func_min_max::val_decimal(my_decimal *dec) { | |
| 3978 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 33 times.
|
33 | assert(fixed == 1); |
| 3979 |
6/6✓ Branch 0 taken 8 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 28 times.
|
33 | if (has_temporal_arg() && data_type() == MYSQL_TYPE_VARCHAR) |
| 3980 | 5 | return decimal_op( | |
| 3981 | 5 | dec); // For correct conversion from temporal value to dec | |
| 3982 | 28 | return Item_func_numhybrid::val_decimal(dec); | |
| 3983 | } | ||
| 3984 | |||
| 3985 | 13 | bool Item_rollup_group_item::get_date(MYSQL_TIME *ltime, | |
| 3986 | my_time_flags_t fuzzydate) { | ||
| 3987 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
|
13 | assert(fixed); |
| 3988 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 11 times.
|
13 | if (rollup_null()) { |
| 3989 | 2 | null_value = true; | |
| 3990 | 2 | return true; | |
| 3991 | } | ||
| 3992 | 11 | return (null_value = args[0]->get_date(ltime, fuzzydate)); | |
| 3993 | } | ||
| 3994 | |||
| 3995 | 5 | bool Item_rollup_group_item::get_time(MYSQL_TIME *ltime) { | |
| 3996 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | assert(fixed); |
| 3997 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 4 times.
|
5 | if (rollup_null()) { |
| 3998 | 1 | null_value = true; | |
| 3999 | 1 | return true; | |
| 4000 | } | ||
| 4001 | 4 | return (null_value = args[0]->get_time(ltime)); | |
| 4002 | } | ||
| 4003 | |||
| 4004 | 323 | double Item_rollup_group_item::val_real() { | |
| 4005 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 323 times.
|
323 | assert(fixed); |
| 4006 |
2/2✓ Branch 0 taken 68 times.
✓ Branch 1 taken 255 times.
|
323 | if (rollup_null()) { |
| 4007 | 68 | null_value = true; | |
| 4008 | 68 | return 0.0; | |
| 4009 | } | ||
| 4010 | 255 | double res = args[0]->val_real(); | |
| 4011 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 240 times.
|
255 | if ((null_value = args[0]->null_value)) return 0.0; |
| 4012 | 240 | return res; | |
| 4013 | } | ||
| 4014 | |||
| 4015 | 7328 | longlong Item_rollup_group_item::val_int() { | |
| 4016 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7328 times.
|
7328 | assert(fixed); |
| 4017 |
2/2✓ Branch 0 taken 1002 times.
✓ Branch 1 taken 6326 times.
|
7328 | if (rollup_null()) { |
| 4018 | 1002 | null_value = true; | |
| 4019 | 1002 | return 0; | |
| 4020 | } | ||
| 4021 | 6326 | longlong res = args[0]->val_int(); | |
| 4022 |
2/2✓ Branch 0 taken 96 times.
✓ Branch 1 taken 6230 times.
|
6326 | if ((null_value = args[0]->null_value)) return 0; |
| 4023 | 6230 | return res; | |
| 4024 | } | ||
| 4025 | |||
| 4026 | 1151 | String *Item_rollup_group_item::val_str(String *str) { | |
| 4027 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1151 times.
|
1151 | assert(fixed); |
| 4028 |
2/2✓ Branch 0 taken 145 times.
✓ Branch 1 taken 1006 times.
|
1151 | if (rollup_null()) { |
| 4029 | 145 | null_value = true; | |
| 4030 | 145 | return nullptr; | |
| 4031 | } | ||
| 4032 | 1006 | String *res = args[0]->val_str(str); | |
| 4033 |
2/2✓ Branch 0 taken 38 times.
✓ Branch 1 taken 968 times.
|
1006 | if ((null_value = args[0]->null_value)) return nullptr; |
| 4034 | 968 | return res; | |
| 4035 | } | ||
| 4036 | |||
| 4037 | 212 | my_decimal *Item_rollup_group_item::val_decimal(my_decimal *dec) { | |
| 4038 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 212 times.
|
212 | assert(fixed); |
| 4039 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 207 times.
|
212 | if (rollup_null()) { |
| 4040 | 5 | null_value = true; | |
| 4041 | 5 | return nullptr; | |
| 4042 | } | ||
| 4043 | 207 | my_decimal *res = args[0]->val_decimal(dec); | |
| 4044 |
2/2✓ Branch 0 taken 39 times.
✓ Branch 1 taken 168 times.
|
207 | if ((null_value = args[0]->null_value)) return nullptr; |
| 4045 | 168 | return res; | |
| 4046 | } | ||
| 4047 | |||
| 4048 | 5 | bool Item_rollup_group_item::val_json(Json_wrapper *result) { | |
| 4049 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | assert(fixed); |
| 4050 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 4 times.
|
5 | if (rollup_null()) { |
| 4051 | 1 | null_value = true; | |
| 4052 | 1 | return false; | |
| 4053 | } | ||
| 4054 | 4 | bool res = args[0]->val_json(result); | |
| 4055 | 4 | null_value = args[0]->null_value; | |
| 4056 | 4 | return res; | |
| 4057 | } | ||
| 4058 | |||
| 4059 | 160 | void Item_rollup_group_item::print(const THD *thd, String *str, | |
| 4060 | enum_query_type query_type) const { | ||
| 4061 |
2/2✓ Branch 0 taken 26 times.
✓ Branch 1 taken 134 times.
|
160 | if (query_type & QT_HIDE_ROLLUP_FUNCTIONS) { |
| 4062 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | print_args(thd, str, 0, query_type); |
| 4063 | 26 | return; | |
| 4064 | } | ||
| 4065 | |||
| 4066 |
1/2✓ Branch 0 taken 134 times.
✗ Branch 1 not taken.
|
134 | str->append(func_name()); |
| 4067 |
1/2✓ Branch 0 taken 134 times.
✗ Branch 1 not taken.
|
134 | str->append('('); |
| 4068 |
1/2✓ Branch 0 taken 134 times.
✗ Branch 1 not taken.
|
134 | print_args(thd, str, 0, query_type); |
| 4069 |
1/2✓ Branch 0 taken 134 times.
✗ Branch 1 not taken.
|
134 | str->append(','); |
| 4070 | char buf[16]; | ||
| 4071 | 134 | snprintf(buf, sizeof(buf), "%d", m_min_rollup_level); | |
| 4072 |
1/2✓ Branch 0 taken 134 times.
✗ Branch 1 not taken.
|
134 | str->append(buf); |
| 4073 |
1/2✓ Branch 0 taken 134 times.
✗ Branch 1 not taken.
|
134 | str->append(')'); |
| 4074 | } | ||
| 4075 | |||
| 4076 | 239 | bool Item_rollup_group_item::eq(const Item *item, bool binary_cmp) const { | |
| 4077 |
4/4✓ Branch 0 taken 140 times.
✓ Branch 1 taken 99 times.
✓ Branch 2 taken 139 times.
✓ Branch 3 taken 1 times.
|
379 | return Item_func::eq(item, binary_cmp) && |
| 4078 | 140 | min_rollup_level() == down_cast<const Item_rollup_group_item *>(item) | |
| 4079 | 379 | ->min_rollup_level(); | |
| 4080 | } | ||
| 4081 | |||
| 4082 | 18106040 | longlong Item_func_length::val_int() { | |
| 4083 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18106040 times.
|
18106040 | assert(fixed == 1); |
| 4084 | 18106040 | String *res = args[0]->val_str(&value); | |
| 4085 |
2/2✓ Branch 0 taken 15234845 times.
✓ Branch 1 taken 2871195 times.
|
18106040 | if (!res) { |
| 4086 | 15234845 | null_value = true; | |
| 4087 | 15234845 | return 0; /* purecov: inspected */ | |
| 4088 | } | ||
| 4089 | 2871195 | null_value = false; | |
| 4090 | 2871195 | return (longlong)res->length(); | |
| 4091 | } | ||
| 4092 | |||
| 4093 | 780198 | longlong Item_func_char_length::val_int() { | |
| 4094 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 780198 times.
|
780198 | assert(fixed == 1); |
| 4095 | 780198 | String *res = args[0]->val_str(&value); | |
| 4096 |
2/2✓ Branch 0 taken 83 times.
✓ Branch 1 taken 780115 times.
|
780198 | if (!res) { |
| 4097 | 83 | null_value = true; | |
| 4098 | 83 | return 0; /* purecov: inspected */ | |
| 4099 | } | ||
| 4100 | 780115 | null_value = false; | |
| 4101 | 780115 | return (longlong)res->numchars(); | |
| 4102 | } | ||
| 4103 | |||
| 4104 | 128 | longlong Item_func_coercibility::val_int() { | |
| 4105 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.
|
128 | assert(fixed == 1); |
| 4106 | 128 | null_value = false; | |
| 4107 | 128 | return (longlong)args[0]->collation.derivation; | |
| 4108 | } | ||
| 4109 | |||
| 4110 | 408445 | bool Item_func_locate::resolve_type(THD *thd) { | |
| 4111 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 408445 times.
|
408445 | if (param_type_is_default(thd, 0, 2)) return true; |
| 4112 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 408445 times.
|
408445 | if (param_type_is_default(thd, 2, 3, MYSQL_TYPE_LONGLONG)) return true; |
| 4113 | 408445 | max_length = MY_INT32_NUM_DECIMAL_DIGITS; | |
| 4114 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 408445 times.
|
408445 | if (agg_arg_charsets_for_string_result(collation, args, 1)) return true; |
| 4115 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 408445 times.
|
408445 | if (simplify_string_args(thd, collation, args + 1, 1)) return true; |
| 4116 | 408445 | return false; | |
| 4117 | } | ||
| 4118 | |||
| 4119 | 732839 | longlong Item_func_locate::val_int() { | |
| 4120 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 732839 times.
|
732839 | assert(fixed); |
| 4121 | // Evaluate the string argument first | ||
| 4122 | 732839 | const CHARSET_INFO *cs = collation.collation; | |
| 4123 |
1/2✓ Branch 0 taken 732839 times.
✗ Branch 1 not taken.
|
732839 | String *a = eval_string_arg(cs, args[0], &value1); |
| 4124 |
2/2✓ Branch 0 taken 141 times.
✓ Branch 1 taken 732698 times.
|
732839 | if (a == nullptr) return error_int(); |
| 4125 | |||
| 4126 | // Evaluate substring argument in same character set as string argument | ||
| 4127 |
1/2✓ Branch 0 taken 732698 times.
✗ Branch 1 not taken.
|
732698 | String *b = eval_string_arg(cs, args[1], &value2); |
| 4128 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 732642 times.
|
732698 | if (b == nullptr) return error_int(); |
| 4129 | |||
| 4130 | 732642 | null_value = false; | |
| 4131 | /* must be longlong to avoid truncation */ | ||
| 4132 | 732642 | longlong start = 0; | |
| 4133 | 732642 | longlong start0 = 0; | |
| 4134 | my_match_t match; | ||
| 4135 | |||
| 4136 |
2/2✓ Branch 0 taken 31325 times.
✓ Branch 1 taken 701317 times.
|
732642 | if (arg_count == 3) { |
| 4137 |
1/2✓ Branch 0 taken 31325 times.
✗ Branch 1 not taken.
|
31325 | const longlong tmp = args[2]->val_int(); |
| 4138 |
6/6✓ Branch 0 taken 31306 times.
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 62 times.
✓ Branch 3 taken 31244 times.
✓ Branch 4 taken 81 times.
✓ Branch 5 taken 31244 times.
|
31325 | if ((null_value = args[2]->null_value) || tmp <= 0) return 0; |
| 4139 | 31244 | start0 = start = tmp - 1; | |
| 4140 | |||
| 4141 |
2/2✓ Branch 0 taken 431 times.
✓ Branch 1 taken 30813 times.
|
31244 | if (start > static_cast<longlong>(a->length())) return 0; |
| 4142 | |||
| 4143 | /* start is now sufficiently valid to pass to charpos function */ | ||
| 4144 |
1/2✓ Branch 0 taken 30813 times.
✗ Branch 1 not taken.
|
30813 | start = a->charpos((int)start); |
| 4145 | |||
| 4146 |
2/2✓ Branch 0 taken 728 times.
✓ Branch 1 taken 30085 times.
|
30813 | if (start + b->length() > a->length()) return 0; |
| 4147 | } | ||
| 4148 | |||
| 4149 |
2/2✓ Branch 0 taken 46 times.
✓ Branch 1 taken 731356 times.
|
731402 | if (!b->length()) // Found empty string at start |
| 4150 | 46 | return start + 1; | |
| 4151 | |||
| 4152 |
3/4✓ Branch 0 taken 731356 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 317094 times.
✓ Branch 3 taken 414262 times.
|
1462712 | if (!cs->coll->strstr(cs, a->ptr() + start, |
| 4153 | 731356 | static_cast<uint>(a->length() - start), b->ptr(), | |
| 4154 | b->length(), &match, 1)) | ||
| 4155 | 317094 | return 0; | |
| 4156 | 414262 | return static_cast<longlong>(match.mb_len) + start0 + 1; | |
| 4157 | } | ||
| 4158 | |||
| 4159 | 37148 | void Item_func_locate::print(const THD *thd, String *str, | |
| 4160 | enum_query_type query_type) const { | ||
| 4161 | 37148 | str->append(STRING_WITH_LEN("locate(")); | |
| 4162 | 37148 | args[1]->print(thd, str, query_type); | |
| 4163 | 37148 | str->append(','); | |
| 4164 | 37148 | args[0]->print(thd, str, query_type); | |
| 4165 |
2/2✓ Branch 0 taken 981 times.
✓ Branch 1 taken 36167 times.
|
37148 | if (arg_count == 3) { |
| 4166 | 981 | str->append(','); | |
| 4167 | 981 | args[2]->print(thd, str, query_type); | |
| 4168 | } | ||
| 4169 | 37148 | str->append(')'); | |
| 4170 | 37148 | } | |
| 4171 | |||
| 4172 | 43 | longlong Item_func_validate_password_strength::val_int() { | |
| 4173 | char buff[STRING_BUFFER_USUAL_SIZE]; | ||
| 4174 | 43 | String value(buff, sizeof(buff), system_charset_info); | |
| 4175 |
1/2✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
|
43 | String *field = args[0]->val_str(&value); |
| 4176 |
6/6✓ Branch 0 taken 41 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 38 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 38 times.
|
43 | if ((null_value = args[0]->null_value) || field->length() == 0) return 0; |
| 4177 |
1/2✓ Branch 0 taken 38 times.
✗ Branch 1 not taken.
|
38 | return (my_calculate_password_strength(field->ptr(), field->length())); |
| 4178 | 43 | } | |
| 4179 | |||
| 4180 | 138 | longlong Item_func_field::val_int() { | |
| 4181 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 138 times.
|
138 | assert(fixed); |
| 4182 | |||
| 4183 |
2/2✓ Branch 0 taken 116 times.
✓ Branch 1 taken 22 times.
|
138 | if (cmp_type == STRING_RESULT) { |
| 4184 | 116 | const CHARSET_INFO *cs = collation.collation; | |
| 4185 | 116 | String *field = eval_string_arg(cs, args[0], &value); | |
| 4186 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 110 times.
|
116 | if (field == nullptr) return 0; |
| 4187 |
2/2✓ Branch 0 taken 207 times.
✓ Branch 1 taken 11 times.
|
218 | for (uint i = 1; i < arg_count; i++) { |
| 4188 | 207 | String *tmp_value = eval_string_arg(cs, args[i], &tmp); | |
| 4189 |
6/6✓ Branch 0 taken 202 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 99 times.
✓ Branch 3 taken 103 times.
✓ Branch 4 taken 99 times.
✓ Branch 5 taken 108 times.
|
207 | if (tmp_value != nullptr && !sortcmp(field, tmp_value, cs)) { |
| 4190 | 99 | return i; | |
| 4191 | } | ||
| 4192 | } | ||
| 4193 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 16 times.
|
22 | } else if (cmp_type == INT_RESULT) { |
| 4194 | 6 | longlong val = args[0]->val_int(); | |
| 4195 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (args[0]->null_value) return 0; |
| 4196 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 5 times.
|
11 | for (uint i = 1; i < arg_count; i++) { |
| 4197 |
5/6✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 5 times.
|
6 | if (val == args[i]->val_int() && !args[i]->null_value) { |
| 4198 | 1 | return i; | |
| 4199 | } | ||
| 4200 | } | ||
| 4201 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
|
16 | } else if (cmp_type == DECIMAL_RESULT) { |
| 4202 | ✗ | my_decimal dec_arg_buf, *dec_arg, dec_buf, | |
| 4203 | ✗ | *dec = args[0]->val_decimal(&dec_buf); | |
| 4204 | ✗ | if (args[0]->null_value) return 0; | |
| 4205 | ✗ | for (uint i = 1; i < arg_count; i++) { | |
| 4206 | ✗ | dec_arg = args[i]->val_decimal(&dec_arg_buf); | |
| 4207 | ✗ | if (!args[i]->null_value && !my_decimal_cmp(dec_arg, dec)) { | |
| 4208 | ✗ | return i; | |
| 4209 | } | ||
| 4210 | } | ||
| 4211 | ✗ | } else { | |
| 4212 | 16 | double val = args[0]->val_real(); | |
| 4213 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 11 times.
|
16 | if (args[0]->null_value) return 0; |
| 4214 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 6 times.
|
30 | for (uint i = 1; i < arg_count; i++) { |
| 4215 |
6/6✓ Branch 0 taken 7 times.
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 19 times.
|
24 | if (val == args[i]->val_real() && !args[i]->null_value) { |
| 4216 | 5 | return i; | |
| 4217 | } | ||
| 4218 | } | ||
| 4219 | } | ||
| 4220 | 22 | return 0; | |
| 4221 | } | ||
| 4222 | |||
| 4223 | 76 | bool Item_func_field::resolve_type(THD *thd) { | |
| 4224 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
|
76 | if (Item_int_func::resolve_type(thd)) return true; |
| 4225 | 76 | set_nullable(false); | |
| 4226 | 76 | max_length = 3; | |
| 4227 | 76 | cmp_type = args[0]->result_type(); | |
| 4228 |
2/2✓ Branch 0 taken 263 times.
✓ Branch 1 taken 76 times.
|
339 | for (uint i = 1; i < arg_count; i++) |
| 4229 | 263 | cmp_type = item_cmp_type(cmp_type, args[i]->result_type()); | |
| 4230 |
2/2✓ Branch 0 taken 59 times.
✓ Branch 1 taken 17 times.
|
76 | if (cmp_type == STRING_RESULT) { |
| 4231 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
|
59 | if (agg_arg_charsets_for_string_result(collation, args, 1)) return true; |
| 4232 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
|
59 | if (simplify_string_args(thd, collation, args + 1, arg_count - 1)) |
| 4233 | ✗ | return true; | |
| 4234 | } | ||
| 4235 | 76 | return false; | |
| 4236 | } | ||
| 4237 | |||
| 4238 | 55243 | longlong Item_func_ascii::val_int() { | |
| 4239 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55243 times.
|
55243 | assert(fixed == 1); |
| 4240 | 55243 | String *res = args[0]->val_str(&value); | |
| 4241 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 55241 times.
|
55243 | if (!res) { |
| 4242 | 2 | null_value = true; | |
| 4243 | 2 | return 0; | |
| 4244 | } | ||
| 4245 | 55241 | null_value = false; | |
| 4246 |
2/2✓ Branch 0 taken 55239 times.
✓ Branch 1 taken 2 times.
|
55241 | return (longlong)(res->length() ? (uchar)(*res)[0] : (uchar)0); |
| 4247 | } | ||
| 4248 | |||
| 4249 | 656429 | longlong Item_func_ord::val_int() { | |
| 4250 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 656429 times.
|
656429 | assert(fixed == 1); |
| 4251 | 656429 | String *res = args[0]->val_str(&value); | |
| 4252 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 656429 times.
|
656429 | if (!res) { |
| 4253 | ✗ | null_value = true; | |
| 4254 | ✗ | return 0; | |
| 4255 | } | ||
| 4256 | 656429 | null_value = false; | |
| 4257 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 656429 times.
|
656429 | if (!res->length()) return 0; |
| 4258 |
2/2✓ Branch 0 taken 611942 times.
✓ Branch 1 taken 44487 times.
|
656429 | if (use_mb(res->charset())) { |
| 4259 | 611942 | const char *str = res->ptr(); | |
| 4260 | 611942 | uint32 n = 0, l = my_ismbchar(res->charset(), str, str + res->length()); | |
| 4261 |
2/2✓ Branch 0 taken 17046 times.
✓ Branch 1 taken 594896 times.
|
611942 | if (!l) return (longlong)((uchar)*str); |
| 4262 |
2/2✓ Branch 0 taken 1251290 times.
✓ Branch 1 taken 594896 times.
|
1846186 | while (l--) n = (n << 8) | (uint32)((uchar)*str++); |
| 4263 | 594896 | return (longlong)n; | |
| 4264 | } | ||
| 4265 | 44487 | return (longlong)((uchar)(*res)[0]); | |
| 4266 | } | ||
| 4267 | |||
| 4268 | /* Search after a string in a string of strings separated by ',' */ | ||
| 4269 | /* Returns number of found type >= 1 or 0 if not found */ | ||
| 4270 | /* This optimizes searching in enums to bit testing! */ | ||
| 4271 | |||
| 4272 | 5681 | bool Item_func_find_in_set::resolve_type(THD *thd) { | |
| 4273 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5681 times.
|
5681 | if (param_type_is_default(thd, 0, -1)) return true; |
| 4274 | 5681 | max_length = 3; // 1-999 | |
| 4275 | |||
| 4276 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5679 times.
|
5681 | if (agg_arg_charsets_for_comparison(cmp_collation, args, 2)) { |
| 4277 | 2 | return true; | |
| 4278 | } | ||
| 4279 |
6/6✓ Branch 0 taken 5403 times.
✓ Branch 1 taken 276 times.
✓ Branch 2 taken 4329 times.
✓ Branch 3 taken 1074 times.
✓ Branch 4 taken 4327 times.
✓ Branch 5 taken 1352 times.
|
10008 | if (args[0]->const_item() && args[1]->type() == FIELD_ITEM && |
| 4280 |
2/2✓ Branch 0 taken 4327 times.
✓ Branch 1 taken 2 times.
|
4329 | args[0]->may_eval_const_item(thd)) { |
| 4281 | 4327 | Field *field = down_cast<Item_field *>(args[1])->field; | |
| 4282 |
2/2✓ Branch 0 taken 4322 times.
✓ Branch 1 taken 5 times.
|
4327 | if (field->real_type() == MYSQL_TYPE_SET) { |
| 4283 | 4322 | String *find = args[0]->val_str(&value); | |
| 4284 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4322 times.
|
4322 | if (thd->is_error()) return true; |
| 4285 |
2/2✓ Branch 0 taken 4320 times.
✓ Branch 1 taken 2 times.
|
4322 | if (find != nullptr) { |
| 4286 | // find is not NULL pointer so args[0] is not a null-value | ||
| 4287 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4320 times.
|
4320 | assert(!args[0]->null_value); |
| 4288 | 8640 | m_enum_value = find_type(down_cast<Field_enum *>(field)->typelib, | |
| 4289 | 4320 | find->ptr(), find->length(), false); | |
| 4290 | } | ||
| 4291 | } | ||
| 4292 | } | ||
| 4293 | 5679 | return false; | |
| 4294 | } | ||
| 4295 | |||
| 4296 | static const char separator = ','; | ||
| 4297 | |||
| 4298 | 4960 | longlong Item_func_find_in_set::val_int() { | |
| 4299 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4960 times.
|
4960 | assert(fixed); |
| 4300 | |||
| 4301 | 4960 | null_value = false; | |
| 4302 | |||
| 4303 |
2/2✓ Branch 0 taken 395 times.
✓ Branch 1 taken 4565 times.
|
4960 | if (m_enum_value != 0) { |
| 4304 | // enum_value is set iff args[0]->const_item() in resolve_type(). | ||
| 4305 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 395 times.
|
395 | assert(args[0]->const_item()); |
| 4306 | |||
| 4307 | 395 | ulonglong tmp = static_cast<ulonglong>(args[1]->val_int()); | |
| 4308 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 394 times.
|
395 | if (args[1]->null_value) return error_int(); |
| 4309 | /* | ||
| 4310 | No need to check args[0]->null_value since enum_value is set iff | ||
| 4311 | args[0] is a non-null const item. Note: no assert on | ||
| 4312 | args[0]->null_value here because args[0] may have been replaced | ||
| 4313 | by an Item_cache on which val_int() has not been called. See | ||
| 4314 | BUG#11766317 | ||
| 4315 | */ | ||
| 4316 |
2/2✓ Branch 0 taken 58 times.
✓ Branch 1 taken 336 times.
|
394 | return (tmp & (1ULL << (m_enum_value - 1))) ? m_enum_value : 0; |
| 4317 | } | ||
| 4318 | |||
| 4319 | 4565 | String *find = args[0]->val_str(&value); | |
| 4320 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 4545 times.
|
4565 | if (find == nullptr) return error_int(); |
| 4321 | |||
| 4322 |
4/4✓ Branch 0 taken 551 times.
✓ Branch 1 taken 3994 times.
✓ Branch 2 taken 55 times.
✓ Branch 3 taken 4490 times.
|
5096 | if (args[1]->type() == FIELD_ITEM && |
| 4323 |
2/2✓ Branch 0 taken 55 times.
✓ Branch 1 taken 496 times.
|
551 | down_cast<Item_field *>(args[1])->field->real_type() == MYSQL_TYPE_SET) { |
| 4324 | 55 | Field *field = down_cast<Item_field *>(args[1])->field; | |
| 4325 | |||
| 4326 | 55 | ulonglong tmp = static_cast<ulonglong>(args[1]->val_int()); | |
| 4327 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 52 times.
|
55 | if (args[1]->null_value) return error_int(); |
| 4328 | |||
| 4329 | 52 | uint value = find_type(down_cast<Field_enum *>(field)->typelib, find->ptr(), | |
| 4330 | find->length(), false); | ||
| 4331 |
4/4✓ Branch 0 taken 10 times.
✓ Branch 1 taken 42 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 2 times.
|
52 | return (value != 0 && (tmp & (1ULL << (value - 1)))) ? value : 0; |
| 4332 | } | ||
| 4333 | |||
| 4334 | 4490 | String *buffer = args[1]->val_str(&value2); | |
| 4335 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4488 times.
|
4490 | if (buffer == nullptr) return error_int(); |
| 4336 | |||
| 4337 |
2/2✓ Branch 0 taken 4230 times.
✓ Branch 1 taken 258 times.
|
4488 | if (buffer->length() >= find->length()) { |
| 4338 | 4230 | my_wc_t wc = 0; | |
| 4339 | 4230 | const CHARSET_INFO *cs = cmp_collation.collation; | |
| 4340 | 4230 | const char *str_begin = buffer->ptr(); | |
| 4341 | 4230 | const char *str_end = buffer->ptr(); | |
| 4342 | 4230 | const char *real_end = str_end + buffer->length(); | |
| 4343 | 4230 | const uchar *find_str = (const uchar *)find->ptr(); | |
| 4344 | 4230 | size_t find_str_len = find->length(); | |
| 4345 | 4230 | int position = 0; | |
| 4346 | while (true) { | ||
| 4347 | int symbol_len; | ||
| 4348 | 72094 | if ((symbol_len = | |
| 4349 |
1/2✓ Branch 0 taken 72094 times.
✗ Branch 1 not taken.
|
72094 | cs->cset->mb_wc(cs, &wc, pointer_cast<const uchar *>(str_end), |
| 4350 |
2/2✓ Branch 0 taken 69181 times.
✓ Branch 1 taken 2913 times.
|
72094 | pointer_cast<const uchar *>(real_end))) > 0) { |
| 4351 | 69181 | const char *substr_end = str_end + symbol_len; | |
| 4352 | 69181 | bool is_last_item = (substr_end == real_end); | |
| 4353 | 69181 | bool is_separator = (wc == (my_wc_t)separator); | |
| 4354 |
4/4✓ Branch 0 taken 66641 times.
✓ Branch 1 taken 2540 times.
✓ Branch 2 taken 3611 times.
✓ Branch 3 taken 63030 times.
|
69181 | if (is_separator || is_last_item) { |
| 4355 | 6151 | position++; | |
| 4356 |
4/4✓ Branch 0 taken 3751 times.
✓ Branch 1 taken 2400 times.
✓ Branch 2 taken 3611 times.
✓ Branch 3 taken 140 times.
|
6151 | if (is_last_item && !is_separator) str_end = substr_end; |
| 4357 |
3/4✓ Branch 0 taken 6151 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1317 times.
✓ Branch 3 taken 4834 times.
|
6151 | if (!my_strnncoll(cs, (const uchar *)str_begin, |
| 4358 | (uint)(str_end - str_begin), find_str, | ||
| 4359 | find_str_len)) | ||
| 4360 | 1317 | return (longlong)position; | |
| 4361 | else | ||
| 4362 | 4834 | str_begin = substr_end; | |
| 4363 | } | ||
| 4364 | 67864 | str_end = substr_end; | |
| 4365 |
3/4✓ Branch 0 taken 2913 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2016 times.
✓ Branch 3 taken 897 times.
|
2913 | } else if (str_end - str_begin == 0 && find_str_len == 0 && |
| 4366 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2015 times.
|
2016 | wc == (my_wc_t)separator) { |
| 4367 | 1 | return ++position; | |
| 4368 | } else { | ||
| 4369 | 2912 | return 0; | |
| 4370 | } | ||
| 4371 | 67864 | } | |
| 4372 | } | ||
| 4373 | 258 | return 0; | |
| 4374 | } | ||
| 4375 | |||
| 4376 | 639 | longlong Item_func_bit_count::val_int() { | |
| 4377 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 639 times.
|
639 | assert(fixed); |
| 4378 |
2/2✓ Branch 0 taken 558 times.
✓ Branch 1 taken 81 times.
|
639 | if (bit_func_returns_binary(args[0], nullptr)) { |
| 4379 | 558 | String *s = args[0]->val_str(&str_value); | |
| 4380 |
3/4✓ Branch 0 taken 554 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 554 times.
|
558 | if (args[0]->null_value || !s) return error_int(); |
| 4381 | |||
| 4382 | 554 | const char *val = s->ptr(); | |
| 4383 | |||
| 4384 | 554 | longlong len = 0; | |
| 4385 | 554 | size_t i = 0; | |
| 4386 | 554 | size_t arg_length = s->length(); | |
| 4387 |
2/2✓ Branch 0 taken 5025 times.
✓ Branch 1 taken 554 times.
|
5579 | while (i + sizeof(longlong) <= arg_length) { |
| 4388 | 5025 | len += my_count_bits(uint8korr(&val[i])); | |
| 4389 | 5025 | i += sizeof(longlong); | |
| 4390 | } | ||
| 4391 |
2/2✓ Branch 0 taken 792 times.
✓ Branch 1 taken 554 times.
|
1346 | while (i < arg_length) { |
| 4392 | 792 | len += _my_bits_nbits[(uchar)val[i]]; | |
| 4393 | 792 | i++; | |
| 4394 | } | ||
| 4395 | |||
| 4396 | 554 | null_value = false; | |
| 4397 | 554 | return len; | |
| 4398 | } | ||
| 4399 | |||
| 4400 | 81 | ulonglong value = (ulonglong)args[0]->val_int(); | |
| 4401 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 68 times.
|
81 | if (args[0]->null_value) return error_int(); /* purecov: inspected */ |
| 4402 | |||
| 4403 | 68 | null_value = false; | |
| 4404 | 68 | return (longlong)my_count_bits(value); | |
| 4405 | } | ||
| 4406 | |||
| 4407 | /**************************************************************************** | ||
| 4408 | ** Functions to handle dynamic loadable functions | ||
| 4409 | ****************************************************************************/ | ||
| 4410 | |||
| 4411 | 19661 | udf_handler::udf_handler(udf_func *udf_arg) | |
| 4412 | 19661 | : u_d(udf_arg), | |
| 4413 | 19661 | m_args_extension(), | |
| 4414 | 19661 | m_return_value_extension(&my_charset_bin, result_type()) {} | |
| 4415 | |||
| 4416 | 19664 | void udf_handler::cleanup() { | |
| 4417 |
4/4✓ Branch 0 taken 19656 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 500 times.
✓ Branch 3 taken 19156 times.
|
19664 | if (!m_original || !m_initialized) return; |
| 4418 | |||
| 4419 | 19156 | clean_buffers(); | |
| 4420 | /* | ||
| 4421 | Make sure to not free the handler from the cleanup() call when | ||
| 4422 | (re)preparing the UDF function call. The handler allocated by | ||
| 4423 | udf_handler::fix_fields() will be used in execution. | ||
| 4424 | */ | ||
| 4425 | 19156 | THD *thd = current_thd; | |
| 4426 |
6/6✓ Branch 0 taken 84 times.
✓ Branch 1 taken 19072 times.
✓ Branch 2 taken 47 times.
✓ Branch 3 taken 37 times.
✓ Branch 4 taken 47 times.
✓ Branch 5 taken 19109 times.
|
19155 | if (thd->stmt_arena->is_stmt_prepare() && thd->stmt_arena->is_repreparing) |
| 4427 | 47 | return; | |
| 4428 | |||
| 4429 |
4/4✓ Branch 0 taken 18739 times.
✓ Branch 1 taken 370 times.
✓ Branch 2 taken 18067 times.
✓ Branch 3 taken 672 times.
|
19109 | if (m_init_func_called && u_d->func_deinit != nullptr) { |
| 4430 | 18067 | (*u_d->func_deinit)(&initid); | |
| 4431 | 18067 | m_init_func_called = false; | |
| 4432 | } | ||
| 4433 |
1/2✓ Branch 0 taken 19109 times.
✗ Branch 1 not taken.
|
19109 | DEBUG_SYNC(current_thd, "udf_handler_destroy_sync"); |
| 4434 | 19109 | free_handler(); | |
| 4435 | } | ||
| 4436 | |||
| 4437 | 19620 | void udf_handler::clean_buffers() { | |
| 4438 |
2/2✓ Branch 0 taken 9923 times.
✓ Branch 1 taken 9697 times.
|
19620 | if (buffers == nullptr) return; |
| 4439 |
2/2✓ Branch 0 taken 25203 times.
✓ Branch 1 taken 9697 times.
|
34900 | for (uint i = 0; i < f_args.arg_count; i++) { |
| 4440 | 25203 | buffers[i].mem_free(); | |
| 4441 | } | ||
| 4442 | } | ||
| 4443 | |||
| 4444 | 19574 | void udf_handler::free_handler() { | |
| 4445 | // deinit() should have been called by cleanup() | ||
| 4446 |
3/6✓ Branch 0 taken 19574 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19574 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 19574 times.
✗ Branch 5 not taken.
|
19574 | assert(m_original && m_initialized && u_d != nullptr); |
| 4447 | 19574 | free_udf(u_d); | |
| 4448 | 19574 | u_d = nullptr; | |
| 4449 | 19574 | m_initialized = false; | |
| 4450 | 19574 | } | |
| 4451 | |||
| 4452 | 19535 | bool Item_udf_func::fix_fields(THD *thd, Item **) { | |
| 4453 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19535 times.
|
19535 | assert(fixed == 0); |
| 4454 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19536 times.
|
19535 | assert(!thd->is_error()); |
| 4455 |
2/2✓ Branch 0 taken 462 times.
✓ Branch 1 taken 19073 times.
|
19536 | if (udf.fix_fields(thd, this, arg_count, args)) return true; |
| 4456 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19075 times.
|
19073 | if (thd->is_error()) return true; |
| 4457 | 19075 | used_tables_cache = udf.used_tables_cache; | |
| 4458 | 19075 | fixed = true; | |
| 4459 | 19075 | return false; | |
| 4460 | } | ||
| 4461 | |||
| 4462 | 19573 | bool udf_handler::fix_fields(THD *thd, Item_result_field *func, uint arg_count, | |
| 4463 | Item **arguments) { | ||
| 4464 | uchar buff[STACK_BUFF_ALLOC]; // Max argument in function | ||
| 4465 |
1/2✓ Branch 0 taken 19574 times.
✗ Branch 1 not taken.
|
19573 | DBUG_TRACE; |
| 4466 | |||
| 4467 |
2/4✓ Branch 0 taken 19573 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19573 times.
|
19574 | if (check_stack_overrun(thd, STACK_MIN_SIZE, buff)) |
| 4468 | ✗ | return true; // Fatal error flag is set! | |
| 4469 | |||
| 4470 |
1/2✓ Branch 0 taken 19574 times.
✗ Branch 1 not taken.
|
19573 | udf_func *tmp_udf = find_udf(u_d->name.str, (uint)u_d->name.length, true); |
| 4471 | |||
| 4472 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19574 times.
|
19574 | if (!tmp_udf) { |
| 4473 | ✗ | my_error(ER_CANT_FIND_UDF, MYF(0), u_d->name.str); | |
| 4474 | ✗ | return true; | |
| 4475 | } | ||
| 4476 | 19574 | u_d = tmp_udf; | |
| 4477 | 19574 | args = arguments; | |
| 4478 | |||
| 4479 | 19574 | m_initialized = true; // Use count was incremented by find_udf() | |
| 4480 | /* | ||
| 4481 | RAII wrapper to free the memory allocated in case of any failure while | ||
| 4482 | initializing the UDF | ||
| 4483 | */ | ||
| 4484 | class cleanup_guard { | ||
| 4485 | public: | ||
| 4486 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19574 times.
|
19574 | cleanup_guard(udf_handler *udf) : m_udf(udf) { assert(udf); } |
| 4487 | 20038 | ~cleanup_guard() { | |
| 4488 |
2/2✓ Branch 0 taken 19108 times.
✓ Branch 1 taken 465 times.
|
19573 | if (m_udf == nullptr) return; |
| 4489 | 465 | m_udf->clean_buffers(); | |
| 4490 | 465 | m_udf->free_handler(); | |
| 4491 | 19573 | } | |
| 4492 | 19107 | void defer() { m_udf = nullptr; } | |
| 4493 | |||
| 4494 | private: | ||
| 4495 | udf_handler *m_udf; | ||
| 4496 | 19574 | } udf_fun_guard(this); | |
| 4497 | |||
| 4498 | /* Fix all arguments */ | ||
| 4499 | 19574 | func->set_nullable(false); | |
| 4500 | 19574 | used_tables_cache = 0; | |
| 4501 | |||
| 4502 |
2/2✓ Branch 0 taken 9656 times.
✓ Branch 1 taken 9918 times.
|
19574 | if ((f_args.arg_count = arg_count)) { |
| 4503 | 9656 | if (!(f_args.arg_type = | |
| 4504 |
1/2✓ Branch 0 taken 9656 times.
✗ Branch 1 not taken.
|
9656 | (Item_result *)(*THR_MALLOC) |
| 4505 |
2/4✓ Branch 0 taken 9656 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9656 times.
|
9656 | ->Alloc(f_args.arg_count * sizeof(Item_result)))) { |
| 4506 | ✗ | return true; | |
| 4507 | } | ||
| 4508 | uint i; | ||
| 4509 | Item **arg, **arg_end; | ||
| 4510 | 9656 | for (i = 0, arg = arguments, arg_end = arguments + arg_count; | |
| 4511 |
2/2✓ Branch 0 taken 25105 times.
✓ Branch 1 taken 9653 times.
|
34758 | arg != arg_end; arg++, i++) { |
| 4512 |
7/8✓ Branch 0 taken 17733 times.
✓ Branch 1 taken 7372 times.
✓ Branch 2 taken 17733 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 17732 times.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 25104 times.
|
25105 | if (!(*arg)->fixed && (*arg)->fix_fields(thd, arg)) { |
| 4513 | 1 | return true; | |
| 4514 | } | ||
| 4515 | // we can't assign 'item' before, because fix_fields() can change arg | ||
| 4516 | 25104 | Item *item = *arg; | |
| 4517 |
3/4✓ Branch 0 taken 25104 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 25102 times.
|
25104 | if (item->check_cols(1)) { |
| 4518 | 2 | return true; | |
| 4519 | } | ||
| 4520 | /* | ||
| 4521 | TODO: We should think about this. It is not always | ||
| 4522 | right way just to set an UDF result to return my_charset_bin | ||
| 4523 | if one argument has binary sorting order. | ||
| 4524 | The result collation should be calculated according to arguments | ||
| 4525 | derivations in some cases and should not in other cases. | ||
| 4526 | Moreover, some arguments can represent a numeric input | ||
| 4527 | which doesn't effect the result character set and collation. | ||
| 4528 | There is no a general rule for UDF. Everything depends on | ||
| 4529 | the particular user defined function. | ||
| 4530 | */ | ||
| 4531 |
2/2✓ Branch 0 taken 7472 times.
✓ Branch 1 taken 17630 times.
|
25102 | if (item->collation.collation->state & MY_CS_BINSORT) |
| 4532 | 7472 | func->collation.set(&my_charset_bin); | |
| 4533 | 25102 | func->m_nullable |= item->m_nullable; | |
| 4534 | 25102 | func->add_accum_properties(item); | |
| 4535 |
1/2✓ Branch 0 taken 25102 times.
✗ Branch 1 not taken.
|
25102 | used_tables_cache |= item->used_tables(); |
| 4536 |
1/2✓ Branch 0 taken 25102 times.
✗ Branch 1 not taken.
|
25102 | f_args.arg_type[i] = item->result_type(); |
| 4537 | } | ||
| 4538 | // TODO: why all following memory is not allocated with 1 call of sql_alloc? | ||
| 4539 | // if (!(buffers = new String[arg_count]) || | ||
| 4540 | 9653 | if (!(buffers = pointer_cast<String *>( | |
| 4541 |
2/4✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9653 times.
✗ Branch 3 not taken.
|
9653 | (*THR_MALLOC)->Alloc(sizeof(String) * arg_count))) || |
| 4542 | 9653 | !(f_args.args = | |
| 4543 |
3/6✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9653 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9653 times.
✗ Branch 5 not taken.
|
9653 | (char **)(*THR_MALLOC)->Alloc(arg_count * sizeof(char *))) || |
| 4544 | 9653 | !(f_args.lengths = | |
| 4545 |
3/6✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9653 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9653 times.
✗ Branch 5 not taken.
|
9653 | (ulong *)(*THR_MALLOC)->Alloc(arg_count * sizeof(long))) || |
| 4546 | 9653 | !(f_args.maybe_null = | |
| 4547 |
3/6✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9653 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9653 times.
✗ Branch 5 not taken.
|
9653 | (char *)(*THR_MALLOC)->Alloc(arg_count * sizeof(char))) || |
| 4548 |
1/2✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
|
9653 | !(num_buffer = (char *)(*THR_MALLOC) |
| 4549 |
2/4✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9653 times.
✗ Branch 3 not taken.
|
9653 | ->Alloc(arg_count * ALIGN_SIZE(sizeof(double)))) || |
| 4550 | 9653 | !(f_args.attributes = | |
| 4551 |
3/6✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9653 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9653 times.
✗ Branch 5 not taken.
|
9653 | (char **)(*THR_MALLOC)->Alloc(arg_count * sizeof(char *))) || |
| 4552 | 9653 | !(f_args.attribute_lengths = | |
| 4553 |
5/10✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9653 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9653 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9653 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 9653 times.
|
28959 | (ulong *)(*THR_MALLOC)->Alloc(arg_count * sizeof(long))) || |
| 4554 | 9653 | !(m_args_extension.charset_info = | |
| 4555 |
1/2✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
|
9653 | (const CHARSET_INFO **)(*THR_MALLOC) |
| 4556 |
2/4✓ Branch 0 taken 9653 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9653 times.
|
9653 | ->Alloc(f_args.arg_count * sizeof(CHARSET_INFO *)))) { |
| 4557 | ✗ | return true; | |
| 4558 | } | ||
| 4559 | } | ||
| 4560 |
2/2✓ Branch 0 taken 25101 times.
✓ Branch 1 taken 19571 times.
|
44672 | for (uint i = 0; i < arg_count; i++) { |
| 4561 | 25101 | (void)::new (buffers + i) String; | |
| 4562 | 25101 | m_args_extension.charset_info[i] = nullptr; | |
| 4563 | } | ||
| 4564 | |||
| 4565 |
2/4✓ Branch 0 taken 19571 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19571 times.
|
19571 | if (func->resolve_type(thd)) return true; |
| 4566 | |||
| 4567 | 19571 | initid.max_length = func->max_length; | |
| 4568 | 19571 | initid.maybe_null = func->m_nullable; | |
| 4569 | 19571 | initid.const_item = used_tables_cache == 0; | |
| 4570 | 19571 | initid.decimals = func->decimals; | |
| 4571 | 19571 | initid.ptr = nullptr; | |
| 4572 | 19571 | initid.extension = &m_return_value_extension; | |
| 4573 | |||
| 4574 |
6/6✓ Branch 0 taken 84 times.
✓ Branch 1 taken 19487 times.
✓ Branch 2 taken 37 times.
✓ Branch 3 taken 47 times.
✓ Branch 4 taken 31 times.
✓ Branch 5 taken 19540 times.
|
19608 | if (thd->stmt_arena->is_stmt_prepare() && !thd->stmt_arena->is_repreparing && |
| 4575 |
2/2✓ Branch 0 taken 31 times.
✓ Branch 1 taken 6 times.
|
37 | !initid.const_item) { |
| 4576 | 31 | udf_fun_guard.defer(); | |
| 4577 | 31 | return false; | |
| 4578 | } | ||
| 4579 |
2/2✓ Branch 0 taken 19201 times.
✓ Branch 1 taken 339 times.
|
19540 | if (u_d->func_init) { |
| 4580 |
3/4✓ Branch 0 taken 19201 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 462 times.
✓ Branch 3 taken 18739 times.
|
19201 | if (call_init_func()) { |
| 4581 | 462 | return true; | |
| 4582 | } | ||
| 4583 | 18739 | func->max_length = min<uint32>(initid.max_length, MAX_BLOB_WIDTH); | |
| 4584 | 18739 | func->m_nullable = initid.maybe_null; | |
| 4585 |
4/4✓ Branch 0 taken 8658 times.
✓ Branch 1 taken 10081 times.
✓ Branch 2 taken 3747 times.
✓ Branch 3 taken 4911 times.
|
18739 | if (!initid.const_item && used_tables_cache == 0) |
| 4586 | 3747 | used_tables_cache = RAND_TABLE_BIT; | |
| 4587 | 18739 | func->decimals = min<uint>(initid.decimals, DECIMAL_NOT_SPECIFIED); | |
| 4588 | /* | ||
| 4589 | For UDFs of type string, override character set and collation from | ||
| 4590 | return value extension specification. | ||
| 4591 | */ | ||
| 4592 |
2/2✓ Branch 0 taken 15812 times.
✓ Branch 1 taken 2926 times.
|
18739 | if (result_type() == STRING_RESULT) |
| 4593 | 15812 | func->set_data_type_string(func->max_length, | |
| 4594 | m_return_value_extension.charset_info); | ||
| 4595 | } | ||
| 4596 | /* | ||
| 4597 | UDF initialization complete so leave the freeing up resources to | ||
| 4598 | cleanup method. | ||
| 4599 | */ | ||
| 4600 | 19075 | udf_fun_guard.defer(); | |
| 4601 | 19078 | return false; | |
| 4602 | 19574 | } | |
| 4603 | |||
| 4604 | 19201 | bool udf_handler::call_init_func() { | |
| 4605 | char init_msg_buff[MYSQL_ERRMSG_SIZE]; | ||
| 4606 | 19201 | *init_msg_buff = '\0'; | |
| 4607 | 19201 | char *to = num_buffer; | |
| 4608 | 19201 | f_args.extension = &m_args_extension; | |
| 4609 | |||
| 4610 |
2/2✓ Branch 0 taken 24995 times.
✓ Branch 1 taken 19201 times.
|
44196 | for (uint i = 0; i < f_args.arg_count; i++) { |
| 4611 | /* | ||
| 4612 | For a constant argument i, args->args[i] points to the argument value. | ||
| 4613 | For non-constant, args->args[i] is NULL. | ||
| 4614 | */ | ||
| 4615 | 24995 | f_args.args[i] = nullptr; // Non-const unless updated below | |
| 4616 | |||
| 4617 | 24995 | f_args.lengths[i] = args[i]->max_length; | |
| 4618 | 24995 | f_args.maybe_null[i] = args[i]->m_nullable; | |
| 4619 | 24995 | f_args.attributes[i] = const_cast<char *>(args[i]->item_name.ptr()); | |
| 4620 | 24995 | f_args.attribute_lengths[i] = args[i]->item_name.length(); | |
| 4621 | 24995 | m_args_extension.charset_info[i] = args[i]->collation.collation; | |
| 4622 | |||
| 4623 |
6/8✓ Branch 0 taken 24995 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24666 times.
✓ Branch 3 taken 329 times.
✓ Branch 4 taken 24666 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 24666 times.
✓ Branch 7 taken 329 times.
|
24995 | if (args[i]->const_for_execution() && !args[i]->has_subquery()) { |
| 4624 |
4/6✓ Branch 0 taken 24666 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21224 times.
✓ Branch 3 taken 3437 times.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
|
24666 | switch (args[i]->result_type()) { |
| 4625 | 21224 | case STRING_RESULT: | |
| 4626 | case DECIMAL_RESULT: { | ||
| 4627 |
1/2✓ Branch 0 taken 21224 times.
✗ Branch 1 not taken.
|
21224 | get_string(i); |
| 4628 | 21224 | break; | |
| 4629 | } | ||
| 4630 | 3437 | case INT_RESULT: | |
| 4631 |
1/2✓ Branch 0 taken 3437 times.
✗ Branch 1 not taken.
|
3437 | *((longlong *)to) = args[i]->val_int(); |
| 4632 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3436 times.
|
3437 | if (args[i]->null_value) continue; |
| 4633 | 3436 | f_args.args[i] = to; | |
| 4634 | 3436 | to += ALIGN_SIZE(sizeof(longlong)); | |
| 4635 | 3436 | break; | |
| 4636 | 5 | case REAL_RESULT: | |
| 4637 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | *((double *)to) = args[i]->val_real(); |
| 4638 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if (args[i]->null_value) continue; |
| 4639 | 5 | f_args.args[i] = to; | |
| 4640 | 5 | to += ALIGN_SIZE(sizeof(double)); | |
| 4641 | 5 | break; | |
| 4642 | ✗ | case ROW_RESULT: | |
| 4643 | default: | ||
| 4644 | // This case should never be chosen | ||
| 4645 | ✗ | assert(0); | |
| 4646 | break; | ||
| 4647 | } | ||
| 4648 | } | ||
| 4649 | } | ||
| 4650 | 19201 | Udf_func_init init = u_d->func_init; | |
| 4651 |
3/4✓ Branch 0 taken 19200 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 462 times.
✓ Branch 3 taken 18738 times.
|
19201 | if ((error = (uchar)init(&initid, &f_args, init_msg_buff))) { |
| 4652 |
1/2✓ Branch 0 taken 462 times.
✗ Branch 1 not taken.
|
462 | my_error(ER_CANT_INITIALIZE_UDF, MYF(0), u_d->name.str, init_msg_buff); |
| 4653 | 462 | return true; | |
| 4654 | } | ||
| 4655 | 18738 | m_init_func_called = true; | |
| 4656 | 18738 | return false; | |
| 4657 | } | ||
| 4658 | |||
| 4659 | 19271 | bool udf_handler::get_arguments() { | |
| 4660 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19271 times.
|
19271 | if (error) return true; // Got an error earlier |
| 4661 | 19271 | char *to = num_buffer; | |
| 4662 |
2/2✓ Branch 0 taken 24271 times.
✓ Branch 1 taken 19271 times.
|
43542 | for (uint i = 0; i < f_args.arg_count; i++) { |
| 4663 | 24271 | f_args.args[i] = nullptr; | |
| 4664 |
4/5✓ Branch 0 taken 20939 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 3258 times.
✓ Branch 3 taken 71 times.
✗ Branch 4 not taken.
|
24271 | switch (f_args.arg_type[i]) { |
| 4665 | 20939 | case STRING_RESULT: | |
| 4666 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20939 times.
|
20939 | if (get_and_convert_string(i)) return true; |
| 4667 | 20939 | break; | |
| 4668 | 3 | case DECIMAL_RESULT: | |
| 4669 | 3 | get_string(i); | |
| 4670 | 3 | break; | |
| 4671 | 3258 | case INT_RESULT: | |
| 4672 | 3258 | *((longlong *)to) = args[i]->val_int(); | |
| 4673 |
2/2✓ Branch 0 taken 3249 times.
✓ Branch 1 taken 9 times.
|
3258 | if (!args[i]->null_value) { |
| 4674 | 3249 | f_args.args[i] = to; | |
| 4675 | 3249 | to += ALIGN_SIZE(sizeof(longlong)); | |
| 4676 | } | ||
| 4677 | 3258 | break; | |
| 4678 | 71 | case REAL_RESULT: | |
| 4679 | 71 | *((double *)to) = args[i]->val_real(); | |
| 4680 |
2/2✓ Branch 0 taken 68 times.
✓ Branch 1 taken 3 times.
|
71 | if (!args[i]->null_value) { |
| 4681 | 68 | f_args.args[i] = to; | |
| 4682 | 68 | to += ALIGN_SIZE(sizeof(double)); | |
| 4683 | } | ||
| 4684 | 71 | break; | |
| 4685 | ✗ | case ROW_RESULT: | |
| 4686 | default: | ||
| 4687 | // This case should never be chosen | ||
| 4688 | ✗ | assert(0); | |
| 4689 | break; | ||
| 4690 | } | ||
| 4691 | } | ||
| 4692 | 19271 | return false; | |
| 4693 | } | ||
| 4694 | |||
| 4695 | 85 | double udf_handler::val_real(bool *null_value) { | |
| 4696 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
|
85 | assert(is_initialized()); |
| 4697 | 85 | is_null = 0; | |
| 4698 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
|
85 | if (get_arguments()) { |
| 4699 | ✗ | *null_value = true; | |
| 4700 | ✗ | return 0.0; | |
| 4701 | } | ||
| 4702 | 85 | Udf_func_double func = (Udf_func_double)u_d->func; | |
| 4703 | 85 | double tmp = func(&initid, &f_args, &is_null, &error); | |
| 4704 |
4/4✓ Branch 0 taken 80 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 76 times.
|
85 | if (is_null || error) { |
| 4705 | 9 | *null_value = true; | |
| 4706 | 9 | return 0.0; | |
| 4707 | } | ||
| 4708 | 76 | *null_value = false; | |
| 4709 | 76 | return tmp; | |
| 4710 | } | ||
| 4711 | |||
| 4712 | 3212 | longlong udf_handler::val_int(bool *null_value) { | |
| 4713 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3212 times.
|
3212 | assert(is_initialized()); |
| 4714 | 3212 | is_null = 0; | |
| 4715 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3212 times.
|
3212 | if (get_arguments()) { |
| 4716 | ✗ | *null_value = true; | |
| 4717 | ✗ | return 0LL; | |
| 4718 | } | ||
| 4719 |
1/2✓ Branch 0 taken 3212 times.
✗ Branch 1 not taken.
|
3212 | DEBUG_SYNC(current_thd, "execute_uninstall_component"); |
| 4720 | 3212 | Udf_func_longlong func = (Udf_func_longlong)u_d->func; | |
| 4721 | 3212 | longlong tmp = func(&initid, &f_args, &is_null, &error); | |
| 4722 |
4/4✓ Branch 0 taken 3204 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 42 times.
✓ Branch 3 taken 3162 times.
|
3212 | if (is_null || error) { |
| 4723 | 50 | *null_value = true; | |
| 4724 | 50 | return 0LL; | |
| 4725 | } | ||
| 4726 | 3162 | *null_value = false; | |
| 4727 | 3162 | return tmp; | |
| 4728 | } | ||
| 4729 | |||
| 4730 | /** | ||
| 4731 | @return | ||
| 4732 | (String*)NULL in case of NULL values | ||
| 4733 | */ | ||
| 4734 | 15899 | String *udf_handler::val_str(String *str, String *save_str) { | |
| 4735 | 15899 | uchar is_null_tmp = 0; | |
| 4736 | ulong res_length; | ||
| 4737 |
1/2✓ Branch 0 taken 15902 times.
✗ Branch 1 not taken.
|
15899 | DBUG_TRACE; |
| 4738 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15902 times.
|
15902 | assert(is_initialized()); |
| 4739 | |||
| 4740 |
2/4✓ Branch 0 taken 15900 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15900 times.
|
15902 | if (get_arguments()) return nullptr; |
| 4741 | |||
| 4742 |
3/6✓ Branch 0 taken 15900 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15902 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15903 times.
✗ Branch 5 not taken.
|
15900 | DEBUG_SYNC(current_thd, "before_string_udf_execution"); |
| 4743 | 15903 | Udf_func_string func = reinterpret_cast<Udf_func_string>(u_d->func); | |
| 4744 | |||
| 4745 |
2/2✓ Branch 0 taken 6278 times.
✓ Branch 1 taken 9625 times.
|
15903 | if ((res_length = str->alloced_length()) < |
| 4746 | MAX_FIELD_WIDTH) { // This happens VERY seldom | ||
| 4747 |
2/4✓ Branch 0 taken 6278 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6278 times.
|
6278 | if (str->alloc(MAX_FIELD_WIDTH)) { |
| 4748 | ✗ | error = 1; | |
| 4749 | ✗ | return nullptr; | |
| 4750 | } | ||
| 4751 | } | ||
| 4752 | char *res = | ||
| 4753 |
1/2✓ Branch 0 taken 15903 times.
✗ Branch 1 not taken.
|
15903 | func(&initid, &f_args, str->ptr(), &res_length, &is_null_tmp, &error); |
| 4754 |
3/8✓ Branch 0 taken 15903 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15903 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15903 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
15903 | DBUG_PRINT("info", ("udf func returned, res_length: %lu", res_length)); |
| 4755 |
6/6✓ Branch 0 taken 15784 times.
✓ Branch 1 taken 119 times.
✓ Branch 2 taken 15674 times.
✓ Branch 3 taken 110 times.
✓ Branch 4 taken 302 times.
✓ Branch 5 taken 15372 times.
|
15903 | if (is_null_tmp || !res || error) // The !res is for safety |
| 4756 | { | ||
| 4757 |
3/8✓ Branch 0 taken 531 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 531 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 531 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
531 | DBUG_PRINT("info", ("Null or error")); |
| 4758 | 531 | return nullptr; | |
| 4759 | } | ||
| 4760 | |||
| 4761 |
1/2✓ Branch 0 taken 15371 times.
✗ Branch 1 not taken.
|
15372 | String *res_str = result_string(res, res_length, str, save_str); |
| 4762 |
3/8✓ Branch 0 taken 15372 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15372 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15372 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
15371 | DBUG_PRINT("exit", ("res_str: %s", res_str->ptr())); |
| 4763 | 15372 | return res_str; | |
| 4764 | 15903 | } | |
| 4765 | |||
| 4766 | /* | ||
| 4767 | For the moment, UDF functions are returning DECIMAL values as strings | ||
| 4768 | */ | ||
| 4769 | |||
| 4770 | ✗ | my_decimal *udf_handler::val_decimal(bool *null_value, my_decimal *dec_buf) { | |
| 4771 | char buf[DECIMAL_MAX_STR_LENGTH + 1]; | ||
| 4772 | ✗ | ulong res_length = DECIMAL_MAX_STR_LENGTH; | |
| 4773 | |||
| 4774 | ✗ | assert(is_initialized()); | |
| 4775 | |||
| 4776 | ✗ | if (get_arguments()) { | |
| 4777 | ✗ | *null_value = true; | |
| 4778 | ✗ | return nullptr; | |
| 4779 | } | ||
| 4780 | ✗ | Udf_func_string func = reinterpret_cast<Udf_func_string>(u_d->func); | |
| 4781 | |||
| 4782 | ✗ | char *res = func(&initid, &f_args, buf, &res_length, &is_null, &error); | |
| 4783 | ✗ | if (is_null || error) { | |
| 4784 | ✗ | *null_value = true; | |
| 4785 | ✗ | return nullptr; | |
| 4786 | } | ||
| 4787 | ✗ | const char *end = res + res_length; | |
| 4788 | ✗ | str2my_decimal(E_DEC_FATAL_ERROR, res, dec_buf, &end); | |
| 4789 | ✗ | return dec_buf; | |
| 4790 | } | ||
| 4791 | |||
| 4792 | 48 | void udf_handler::clear() { | |
| 4793 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
|
48 | assert(is_initialized()); |
| 4794 | 48 | is_null = 0; | |
| 4795 | 48 | Udf_func_clear func = u_d->func_clear; | |
| 4796 | 48 | func(&initid, &is_null, &error); | |
| 4797 | 48 | } | |
| 4798 | |||
| 4799 | 74 | void udf_handler::add(bool *null_value) { | |
| 4800 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
|
74 | assert(is_initialized()); |
| 4801 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
|
74 | if (get_arguments()) { |
| 4802 | ✗ | *null_value = true; | |
| 4803 | ✗ | return; | |
| 4804 | } | ||
| 4805 | 74 | Udf_func_add func = u_d->func_add; | |
| 4806 | 74 | func(&initid, &f_args, &is_null, &error); | |
| 4807 |
2/4✓ Branch 0 taken 74 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 74 times.
|
74 | *null_value = (bool)(is_null || error); |
| 4808 | } | ||
| 4809 | |||
| 4810 | /** | ||
| 4811 | Process the result string returned by the udf() method. The charset | ||
| 4812 | info might have changed therefore updates the same String. If user | ||
| 4813 | used the input String as result string then return the same. | ||
| 4814 | |||
| 4815 | @param [in] res the result string returned by the udf() method. | ||
| 4816 | @param [in] res_length length of the string | ||
| 4817 | @param [out] str The input result string passed to the udf() method | ||
| 4818 | @param [out] save_str Keeps copy of the returned String | ||
| 4819 | |||
| 4820 | @returns A pointer to either the str or save_str that points | ||
| 4821 | to final result String | ||
| 4822 | */ | ||
| 4823 | 15371 | String *udf_handler::result_string(const char *res, size_t res_length, | |
| 4824 | String *str, String *save_str) { | ||
| 4825 | 15371 | const auto *charset = m_return_value_extension.charset_info; | |
| 4826 | 15371 | String *res_str = nullptr; | |
| 4827 |
2/2✓ Branch 0 taken 8918 times.
✓ Branch 1 taken 6454 times.
|
15371 | if (res == str->ptr()) { |
| 4828 | 8918 | res_str = str; | |
| 4829 | 8918 | res_str->length(res_length); | |
| 4830 | 8918 | res_str->set_charset(charset); | |
| 4831 | } else { | ||
| 4832 | 6454 | res_str = save_str; | |
| 4833 | 6454 | res_str->set(res, res_length, charset); | |
| 4834 | } | ||
| 4835 | 15372 | return res_str; | |
| 4836 | } | ||
| 4837 | |||
| 4838 | /** | ||
| 4839 | Get the details of the input String arguments. | ||
| 4840 | |||
| 4841 | @param [in] index of the argument to be looked in the arguments array | ||
| 4842 | */ | ||
| 4843 | 21227 | void udf_handler::get_string(uint index) { | |
| 4844 | 21227 | String *res = args[index]->val_str(&buffers[index]); | |
| 4845 |
2/2✓ Branch 0 taken 21139 times.
✓ Branch 1 taken 88 times.
|
21227 | if (!args[index]->null_value) { |
| 4846 | 21139 | f_args.args[index] = res->ptr(); | |
| 4847 | 21139 | f_args.lengths[index] = res->length(); | |
| 4848 | } else { | ||
| 4849 | 88 | f_args.lengths[index] = 0; | |
| 4850 | } | ||
| 4851 | 21227 | } | |
| 4852 | |||
| 4853 | /** | ||
| 4854 | Get the details of the input String argument. | ||
| 4855 | If the charset of the input argument is not same as specified by the | ||
| 4856 | user then convert the String. | ||
| 4857 | |||
| 4858 | @param [in] index of the argument to be looked in the arguments array | ||
| 4859 | |||
| 4860 | @retval false Able to fetch the argument details | ||
| 4861 | @retval true Otherwise | ||
| 4862 | */ | ||
| 4863 | 20939 | bool udf_handler::get_and_convert_string(uint index) { | |
| 4864 | 20939 | String *res = args[index]->val_str(&buffers[index]); | |
| 4865 | |||
| 4866 | /* m_args_extension.charset_info[index] is a legitimate charset */ | ||
| 4867 |
4/4✓ Branch 0 taken 20879 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 20878 times.
✓ Branch 3 taken 1 times.
|
20939 | if (res != nullptr && m_args_extension.charset_info[index] != nullptr) { |
| 4868 |
2/2✓ Branch 0 taken 1418 times.
✓ Branch 1 taken 19460 times.
|
20878 | if (res->charset() != m_args_extension.charset_info[index]) { |
| 4869 | 1418 | String temp; | |
| 4870 | uint dummy; | ||
| 4871 |
2/4✓ Branch 0 taken 1418 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1418 times.
|
1418 | if (temp.copy(res->ptr(), res->length(), res->charset(), |
| 4872 | 1418 | m_args_extension.charset_info[index], &dummy)) { | |
| 4873 | ✗ | return true; | |
| 4874 | } | ||
| 4875 | 1418 | *res = std::move(temp); | |
| 4876 |
1/2✓ Branch 0 taken 1418 times.
✗ Branch 1 not taken.
|
1418 | } |
| 4877 | } | ||
| 4878 |
2/2✓ Branch 0 taken 20879 times.
✓ Branch 1 taken 60 times.
|
20939 | if (!args[index]->null_value) { |
| 4879 | 20879 | f_args.args[index] = res->c_ptr_safe(); | |
| 4880 | 20879 | f_args.lengths[index] = res->length(); | |
| 4881 | } else { | ||
| 4882 | 60 | f_args.lengths[index] = 0; | |
| 4883 | } | ||
| 4884 | 20939 | return false; | |
| 4885 | } | ||
| 4886 | |||
| 4887 | 19624 | bool Item_udf_func::itemize(Parse_context *pc, Item **res) { | |
| 4888 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19623 times.
|
19624 | if (skip_itemize(res)) return false; |
| 4889 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 19622 times.
|
19623 | if (super::itemize(pc, res)) return true; |
| 4890 | 19622 | pc->thd->lex->set_has_udf(); | |
| 4891 | 19621 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_UDF); | |
| 4892 | 19625 | pc->thd->lex->safe_to_cache_query = false; | |
| 4893 | 19625 | return false; | |
| 4894 | } | ||
| 4895 | |||
| 4896 | 19615 | void Item_udf_func::cleanup() { | |
| 4897 | 19615 | udf.cleanup(); | |
| 4898 | 19616 | str_value.mem_free(); | |
| 4899 | 19616 | Item_func::cleanup(); | |
| 4900 | 19616 | } | |
| 4901 | |||
| 4902 | 14 | void Item_udf_func::print(const THD *thd, String *str, | |
| 4903 | enum_query_type query_type) const { | ||
| 4904 |
1/2✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
|
14 | str->append(func_name()); |
| 4905 | 14 | str->append('('); | |
| 4906 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 14 times.
|
28 | for (uint i = 0; i < arg_count; i++) { |
| 4907 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (i != 0) str->append(','); |
| 4908 | 14 | args[i]->print_item_w_name(thd, str, query_type); | |
| 4909 | } | ||
| 4910 | 14 | str->append(')'); | |
| 4911 | 14 | } | |
| 4912 | |||
| 4913 | 67 | double Item_func_udf_float::val_real() { | |
| 4914 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 67 times.
|
67 | assert(fixed == 1); |
| 4915 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 67 times.
|
67 | DBUG_PRINT("info", ("result_type: %d arg_count: %d", args[0]->result_type(), |
| 4916 | arg_count)); | ||
| 4917 | 67 | return udf.val_real(&null_value); | |
| 4918 | } | ||
| 4919 | |||
| 4920 | ✗ | String *Item_func_udf_float::val_str(String *str) { | |
| 4921 | ✗ | assert(fixed == 1); | |
| 4922 | ✗ | double nr = val_real(); | |
| 4923 | ✗ | if (null_value) return nullptr; /* purecov: inspected */ | |
| 4924 | ✗ | str->set_real(nr, decimals, &my_charset_bin); | |
| 4925 | ✗ | return str; | |
| 4926 | } | ||
| 4927 | |||
| 4928 | 3186 | longlong Item_func_udf_int::val_int() { | |
| 4929 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3186 times.
|
3186 | assert(fixed == 1); |
| 4930 | 3186 | return udf.val_int(&null_value); | |
| 4931 | } | ||
| 4932 | |||
| 4933 | 42 | String *Item_func_udf_int::val_str(String *str) { | |
| 4934 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
|
42 | assert(fixed == 1); |
| 4935 | 42 | longlong nr = val_int(); | |
| 4936 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
|
42 | if (null_value) return nullptr; |
| 4937 | 42 | str->set_int(nr, unsigned_flag, &my_charset_bin); | |
| 4938 | 42 | return str; | |
| 4939 | } | ||
| 4940 | |||
| 4941 | ✗ | longlong Item_func_udf_decimal::val_int() { | |
| 4942 | ✗ | my_decimal dec_buf, *dec = udf.val_decimal(&null_value, &dec_buf); | |
| 4943 | longlong result; | ||
| 4944 | ✗ | if (null_value) return 0; | |
| 4945 | ✗ | my_decimal2int(E_DEC_FATAL_ERROR, dec, unsigned_flag, &result); | |
| 4946 | ✗ | return result; | |
| 4947 | } | ||
| 4948 | |||
| 4949 | ✗ | double Item_func_udf_decimal::val_real() { | |
| 4950 | ✗ | my_decimal dec_buf, *dec = udf.val_decimal(&null_value, &dec_buf); | |
| 4951 | double result; | ||
| 4952 | ✗ | if (null_value) return 0.0; | |
| 4953 | ✗ | my_decimal2double(E_DEC_FATAL_ERROR, dec, &result); | |
| 4954 | ✗ | return result; | |
| 4955 | } | ||
| 4956 | |||
| 4957 | ✗ | my_decimal *Item_func_udf_decimal::val_decimal(my_decimal *dec_buf) { | |
| 4958 | ✗ | return udf.val_decimal(&null_value, dec_buf); | |
| 4959 | } | ||
| 4960 | |||
| 4961 | ✗ | String *Item_func_udf_decimal::val_str(String *str) { | |
| 4962 | ✗ | my_decimal dec_buf, *dec = udf.val_decimal(&null_value, &dec_buf); | |
| 4963 | ✗ | if (null_value) return nullptr; | |
| 4964 | ✗ | if (str->length() < DECIMAL_MAX_STR_LENGTH) | |
| 4965 | ✗ | str->length(DECIMAL_MAX_STR_LENGTH); | |
| 4966 | ✗ | my_decimal_round(E_DEC_FATAL_ERROR, dec, decimals, false, &dec_buf); | |
| 4967 | ✗ | my_decimal2string(E_DEC_FATAL_ERROR, &dec_buf, str); | |
| 4968 | ✗ | return str; | |
| 4969 | } | ||
| 4970 | |||
| 4971 | ✗ | bool Item_func_udf_decimal::resolve_type(THD *) { | |
| 4972 | ✗ | set_data_type(MYSQL_TYPE_NEWDECIMAL); | |
| 4973 | ✗ | fix_num_length_and_dec(); | |
| 4974 | ✗ | return false; | |
| 4975 | } | ||
| 4976 | |||
| 4977 | /* Default max_length is max argument length */ | ||
| 4978 | |||
| 4979 | 16194 | bool Item_func_udf_str::resolve_type(THD *) { | |
| 4980 | 16194 | uint result_length = 0; | |
| 4981 |
2/2✓ Branch 0 taken 16608 times.
✓ Branch 1 taken 16194 times.
|
32802 | for (uint i = 0; i < arg_count; i++) |
| 4982 | 16608 | result_length = max(result_length, args[i]->max_length); | |
| 4983 | // If the UDF has an init function, this may be overridden later. | ||
| 4984 | 16194 | set_data_type_string(result_length, &my_charset_bin); | |
| 4985 | 16194 | return false; | |
| 4986 | } | ||
| 4987 | |||
| 4988 | 15899 | String *Item_func_udf_str::val_str(String *str) { | |
| 4989 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15899 times.
|
15899 | assert(fixed == 1); |
| 4990 | 15899 | String *res = udf.val_str(str, &str_value); | |
| 4991 | 15903 | null_value = !res; | |
| 4992 | 15903 | return res; | |
| 4993 | } | ||
| 4994 | |||
| 4995 | 19525 | bool Item_source_pos_wait::itemize(Parse_context *pc, Item **res) { | |
| 4996 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19525 times.
|
19525 | if (skip_itemize(res)) return false; |
| 4997 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19525 times.
|
19525 | if (super::itemize(pc, res)) return true; |
| 4998 | 19525 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 4999 | 19525 | pc->thd->lex->safe_to_cache_query = false; | |
| 5000 | 19525 | return false; | |
| 5001 | } | ||
| 5002 | |||
| 5003 | /** | ||
| 5004 | Wait until we are at or past the given position in the master binlog | ||
| 5005 | on the slave. | ||
| 5006 | */ | ||
| 5007 | |||
| 5008 | 19520 | longlong Item_source_pos_wait::val_int() { | |
| 5009 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19520 times.
|
19520 | assert(fixed == 1); |
| 5010 | 19520 | THD *thd = current_thd; | |
| 5011 | 19520 | String *log_name = args[0]->val_str(&value); | |
| 5012 | 19520 | int event_count = 0; | |
| 5013 | |||
| 5014 | 19520 | null_value = false; | |
| 5015 |
4/8✓ Branch 0 taken 19520 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19520 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 19520 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 19520 times.
|
19520 | if (thd->slave_thread || !log_name || !log_name->length()) { |
| 5016 | ✗ | null_value = true; | |
| 5017 | ✗ | return 0; | |
| 5018 | } | ||
| 5019 | Master_info *mi; | ||
| 5020 | 19520 | longlong pos = (ulong)args[1]->val_int(); | |
| 5021 |
2/2✓ Branch 0 taken 19511 times.
✓ Branch 1 taken 9 times.
|
19520 | double timeout = (arg_count >= 3) ? args[2]->val_real() : 0; |
| 5022 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 19515 times.
|
19520 | if (timeout < 0) { |
| 5023 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
|
5 | if (thd->is_strict_mode()) { |
| 5024 | 3 | my_error(ER_WRONG_ARGUMENTS, MYF(0), "SOURCE_POS_WAIT."); | |
| 5025 | } else { | ||
| 5026 | 2 | push_warning_printf(thd, Sql_condition::SL_WARNING, ER_WRONG_ARGUMENTS, | |
| 5027 | ER_THD(thd, ER_WRONG_ARGUMENTS), "SOURCE_POS_WAIT."); | ||
| 5028 | 2 | null_value = true; | |
| 5029 | } | ||
| 5030 | 5 | return 0; | |
| 5031 | } | ||
| 5032 | |||
| 5033 | 19515 | channel_map.rdlock(); | |
| 5034 | |||
| 5035 |
2/2✓ Branch 0 taken 221 times.
✓ Branch 1 taken 19294 times.
|
19515 | if (arg_count == 4) { |
| 5036 | String *channel_str; | ||
| 5037 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 221 times.
|
221 | if (!(channel_str = args[3]->val_str(&value))) { |
| 5038 | ✗ | null_value = true; | |
| 5039 | ✗ | return 0; | |
| 5040 | } | ||
| 5041 | |||
| 5042 | 221 | mi = channel_map.get_mi(channel_str->ptr()); | |
| 5043 | |||
| 5044 | } else { | ||
| 5045 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 19290 times.
|
19294 | if (channel_map.get_num_instances() > 1) { |
| 5046 | 4 | mi = nullptr; | |
| 5047 | 4 | my_error(ER_SLAVE_MULTIPLE_CHANNELS_CMD, MYF(0)); | |
| 5048 | } else | ||
| 5049 | 19290 | mi = channel_map.get_default_channel_mi(); | |
| 5050 | } | ||
| 5051 | |||
| 5052 |
2/2✓ Branch 0 taken 19507 times.
✓ Branch 1 taken 8 times.
|
19515 | if (mi != nullptr) mi->inc_reference(); |
| 5053 | |||
| 5054 | 19515 | channel_map.unlock(); | |
| 5055 | |||
| 5056 |
6/6✓ Branch 0 taken 19507 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 22 times.
✓ Branch 3 taken 19485 times.
✓ Branch 4 taken 30 times.
✓ Branch 5 taken 19485 times.
|
19515 | if (mi == nullptr || (event_count = mi->rli->wait_for_pos(thd, log_name, pos, |
| 5057 | timeout)) == -2) { | ||
| 5058 | 30 | null_value = true; | |
| 5059 | 30 | event_count = 0; | |
| 5060 | } | ||
| 5061 | |||
| 5062 |
2/2✓ Branch 0 taken 19507 times.
✓ Branch 1 taken 8 times.
|
19515 | if (mi != nullptr) mi->dec_reference(); |
| 5063 | 19515 | return event_count; | |
| 5064 | } | ||
| 5065 | |||
| 5066 | 7 | longlong Item_master_pos_wait::val_int() { | |
| 5067 | 7 | push_deprecated_warn(current_thd, "MASTER_POS_WAIT", "SOURCE_POS_WAIT"); | |
| 5068 | 7 | return Item_source_pos_wait::val_int(); | |
| 5069 | } | ||
| 5070 | |||
| 5071 | 2338 | bool Item_wait_for_executed_gtid_set::itemize(Parse_context *pc, Item **res) { | |
| 5072 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2338 times.
|
2338 | if (skip_itemize(res)) return false; |
| 5073 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2338 times.
|
2338 | if (super::itemize(pc, res)) return true; |
| 5074 | /* | ||
| 5075 | It is unsafe because the return value depends on timing. If the timeout | ||
| 5076 | happens, the return value is different from the one in which the function | ||
| 5077 | returns with success. | ||
| 5078 | */ | ||
| 5079 | 2338 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 5080 | 2338 | pc->thd->lex->safe_to_cache_query = false; | |
| 5081 | 2338 | return false; | |
| 5082 | } | ||
| 5083 | |||
| 5084 | /** | ||
| 5085 | Wait until the given gtid_set is found in the executed gtid_set independent | ||
| 5086 | of the slave threads. | ||
| 5087 | */ | ||
| 5088 | 4150 | longlong Item_wait_for_executed_gtid_set::val_int() { | |
| 5089 |
1/2✓ Branch 0 taken 4150 times.
✗ Branch 1 not taken.
|
4150 | DBUG_TRACE; |
| 5090 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4150 times.
|
4150 | assert(fixed); |
| 5091 |
1/2✓ Branch 0 taken 4150 times.
✗ Branch 1 not taken.
|
4150 | THD *thd = current_thd; |
| 5092 | |||
| 5093 | 4150 | null_value = false; | |
| 5094 | |||
| 5095 |
1/2✓ Branch 0 taken 4150 times.
✗ Branch 1 not taken.
|
4150 | String *gtid_text = args[0]->val_str(&value); |
| 5096 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4146 times.
|
4150 | if (gtid_text == nullptr) { |
| 5097 | /* | ||
| 5098 | Usually, an argument that is NULL causes an SQL function to return NULL, | ||
| 5099 | however since this is a function with side-effects, a NULL value is | ||
| 5100 | treated as an error. | ||
| 5101 | */ | ||
| 5102 |
2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
4 | if (!thd->is_error()) { |
| 5103 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | my_error(ER_MALFORMED_GTID_SET_SPECIFICATION, MYF(0), "NULL"); |
| 5104 | } | ||
| 5105 | 4 | return error_int(); | |
| 5106 | } | ||
| 5107 | |||
| 5108 | // Waiting for a GTID in a slave thread could cause the slave to | ||
| 5109 | // hang/deadlock. | ||
| 5110 | // @todo: Return error instead of NULL | ||
| 5111 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4144 times.
|
4146 | if (thd->slave_thread) { |
| 5112 | 2 | return error_int(); | |
| 5113 | } | ||
| 5114 | |||
| 5115 |
1/2✓ Branch 0 taken 4144 times.
✗ Branch 1 not taken.
|
4144 | Gtid_set wait_for_gtid_set(global_sid_map, nullptr); |
| 5116 | |||
| 5117 |
1/2✓ Branch 0 taken 4144 times.
✗ Branch 1 not taken.
|
4144 | global_sid_lock->rdlock(); |
| 5118 |
3/4✓ Branch 0 taken 4144 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 4140 times.
|
4144 | if (global_gtid_mode.get() == Gtid_mode::OFF) { |
| 5119 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | global_sid_lock->unlock(); |
| 5120 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | my_error(ER_GTID_MODE_OFF, MYF(0), "use WAIT_FOR_EXECUTED_GTID_SET"); |
| 5121 | 4 | return error_int(); | |
| 5122 | } | ||
| 5123 | |||
| 5124 |
4/6✓ Branch 0 taken 4140 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4140 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 4137 times.
|
4140 | if (wait_for_gtid_set.add_gtid_text(gtid_text->c_ptr_safe()) != |
| 5125 | RETURN_STATUS_OK) { | ||
| 5126 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | global_sid_lock->unlock(); |
| 5127 | // Error has already been generated. | ||
| 5128 | 3 | return error_int(); | |
| 5129 | } | ||
| 5130 | |||
| 5131 | // Cannot wait for a GTID that the thread owns since that would | ||
| 5132 | // immediately deadlock. | ||
| 5133 |
4/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4135 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 4136 times.
|
4139 | if (thd->owned_gtid.sidno > 0 && |
| 5134 |
3/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
|
2 | wait_for_gtid_set.contains_gtid(thd->owned_gtid)) { |
| 5135 | char buf[Gtid::MAX_TEXT_LENGTH + 1]; | ||
| 5136 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | thd->owned_gtid.to_string(global_sid_map, buf); |
| 5137 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | global_sid_lock->unlock(); |
| 5138 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_error(ER_CANT_WAIT_FOR_EXECUTED_GTID_SET_WHILE_OWNING_A_GTID, MYF(0), |
| 5139 | buf); | ||
| 5140 | 1 | return error_int(); | |
| 5141 | } | ||
| 5142 | |||
| 5143 |
1/2✓ Branch 0 taken 4136 times.
✗ Branch 1 not taken.
|
4136 | gtid_state->begin_gtid_wait(); |
| 5144 | |||
| 5145 |
3/4✓ Branch 0 taken 4065 times.
✓ Branch 1 taken 71 times.
✓ Branch 2 taken 4065 times.
✗ Branch 3 not taken.
|
4136 | double timeout = (arg_count == 2) ? args[1]->val_real() : 0; |
| 5146 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4130 times.
|
4136 | if (timeout < 0) { |
| 5147 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
|
6 | if (thd->is_strict_mode()) { |
| 5148 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | my_error(ER_WRONG_ARGUMENTS, MYF(0), "WAIT_FOR_EXECUTED_GTID_SET."); |
| 5149 | } else { | ||
| 5150 |
2/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
|
3 | push_warning_printf(thd, Sql_condition::SL_WARNING, ER_WRONG_ARGUMENTS, |
| 5151 | ER_THD(thd, ER_WRONG_ARGUMENTS), | ||
| 5152 | "WAIT_FOR_EXECUTED_GTID_SET."); | ||
| 5153 | } | ||
| 5154 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | gtid_state->end_gtid_wait(); |
| 5155 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | global_sid_lock->unlock(); |
| 5156 | 6 | return error_int(); | |
| 5157 | } | ||
| 5158 | |||
| 5159 |
1/2✓ Branch 0 taken 4130 times.
✗ Branch 1 not taken.
|
4130 | bool result = gtid_state->wait_for_gtid_set(thd, &wait_for_gtid_set, timeout); |
| 5160 |
1/2✓ Branch 0 taken 4130 times.
✗ Branch 1 not taken.
|
4130 | global_sid_lock->unlock(); |
| 5161 |
1/2✓ Branch 0 taken 4130 times.
✗ Branch 1 not taken.
|
4130 | gtid_state->end_gtid_wait(); |
| 5162 | |||
| 5163 | 4130 | return result; | |
| 5164 | 4150 | } | |
| 5165 | |||
| 5166 | 19 | Item_master_gtid_set_wait::Item_master_gtid_set_wait(const POS &pos, Item *a) | |
| 5167 | 19 | : Item_int_func(pos, a) { | |
| 5168 |
2/4✓ Branch 0 taken 19 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
✗ Branch 3 not taken.
|
19 | push_deprecated_warn(current_thd, "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS", |
| 5169 | "WAIT_FOR_EXECUTED_GTID_SET"); | ||
| 5170 | 19 | } | |
| 5171 | |||
| 5172 | 1903 | Item_master_gtid_set_wait::Item_master_gtid_set_wait(const POS &pos, Item *a, | |
| 5173 | 1903 | Item *b) | |
| 5174 | 1903 | : Item_int_func(pos, a, b) { | |
| 5175 |
2/4✓ Branch 0 taken 1903 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1903 times.
✗ Branch 3 not taken.
|
1903 | push_deprecated_warn(current_thd, "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS", |
| 5176 | "WAIT_FOR_EXECUTED_GTID_SET"); | ||
| 5177 | 1903 | } | |
| 5178 | |||
| 5179 | 88 | Item_master_gtid_set_wait::Item_master_gtid_set_wait(const POS &pos, Item *a, | |
| 5180 | 88 | Item *b, Item *c) | |
| 5181 | 88 | : Item_int_func(pos, a, b, c) { | |
| 5182 |
2/4✓ Branch 0 taken 88 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
✗ Branch 3 not taken.
|
88 | push_deprecated_warn(current_thd, "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS", |
| 5183 | "WAIT_FOR_EXECUTED_GTID_SET"); | ||
| 5184 | 88 | } | |
| 5185 | |||
| 5186 | 2010 | bool Item_master_gtid_set_wait::itemize(Parse_context *pc, Item **res) { | |
| 5187 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2010 times.
|
2010 | if (skip_itemize(res)) return false; |
| 5188 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2010 times.
|
2010 | if (super::itemize(pc, res)) return true; |
| 5189 | 2010 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 5190 | 2010 | pc->thd->lex->safe_to_cache_query = false; | |
| 5191 | 2010 | return false; | |
| 5192 | } | ||
| 5193 | |||
| 5194 | 2007 | longlong Item_master_gtid_set_wait::val_int() { | |
| 5195 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2007 times.
|
2007 | assert(fixed); |
| 5196 |
1/2✓ Branch 0 taken 2007 times.
✗ Branch 1 not taken.
|
2007 | DBUG_TRACE; |
| 5197 | 2007 | int event_count = 0; | |
| 5198 | |||
| 5199 | 2007 | null_value = false; | |
| 5200 | |||
| 5201 |
1/2✓ Branch 0 taken 2007 times.
✗ Branch 1 not taken.
|
2007 | String *gtid = args[0]->val_str(&value); |
| 5202 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2007 times.
|
2007 | if (gtid == nullptr) { |
| 5203 | ✗ | return error_int(); | |
| 5204 | } | ||
| 5205 | |||
| 5206 |
1/2✓ Branch 0 taken 2007 times.
✗ Branch 1 not taken.
|
2007 | THD *thd = current_thd; |
| 5207 | 2007 | Master_info *mi = nullptr; | |
| 5208 |
3/4✓ Branch 0 taken 1989 times.
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 1989 times.
✗ Branch 3 not taken.
|
2007 | double timeout = (arg_count >= 2) ? args[1]->val_real() : 0; |
| 5209 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2003 times.
|
2007 | if (timeout < 0) { |
| 5210 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
|
4 | if (thd->is_strict_mode()) { |
| 5211 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | my_error(ER_WRONG_ARGUMENTS, MYF(0), |
| 5212 | "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS."); | ||
| 5213 | } else { | ||
| 5214 |
2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
2 | push_warning_printf(thd, Sql_condition::SL_WARNING, ER_WRONG_ARGUMENTS, |
| 5215 | ER_THD(thd, ER_WRONG_ARGUMENTS), | ||
| 5216 | "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS."); | ||
| 5217 | } | ||
| 5218 | 4 | return error_int(); | |
| 5219 | } | ||
| 5220 | |||
| 5221 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2003 times.
|
2003 | if (thd->slave_thread) { |
| 5222 | ✗ | return error_int(); | |
| 5223 | } | ||
| 5224 | |||
| 5225 |
1/2✓ Branch 0 taken 2003 times.
✗ Branch 1 not taken.
|
2003 | channel_map.rdlock(); |
| 5226 | |||
| 5227 | /* If replication channel is mentioned */ | ||
| 5228 |
2/2✓ Branch 0 taken 87 times.
✓ Branch 1 taken 1916 times.
|
2003 | if (arg_count == 3) { |
| 5229 | String *channel_str; | ||
| 5230 |
2/4✓ Branch 0 taken 87 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 87 times.
|
87 | if (!(channel_str = args[2]->val_str(&value))) { |
| 5231 | ✗ | channel_map.unlock(); | |
| 5232 | ✗ | return error_int(); | |
| 5233 | } | ||
| 5234 |
1/2✓ Branch 0 taken 87 times.
✗ Branch 1 not taken.
|
87 | mi = channel_map.get_mi(channel_str->ptr()); |
| 5235 | } else { | ||
| 5236 |
3/4✓ Branch 0 taken 1916 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 1913 times.
|
1916 | if (channel_map.get_num_instances() > 1) { |
| 5237 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | channel_map.unlock(); |
| 5238 | 3 | mi = nullptr; | |
| 5239 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | my_error(ER_SLAVE_MULTIPLE_CHANNELS_CMD, MYF(0)); |
| 5240 | 3 | return error_int(); | |
| 5241 | } else | ||
| 5242 |
1/2✓ Branch 0 taken 1913 times.
✗ Branch 1 not taken.
|
1913 | mi = channel_map.get_default_channel_mi(); |
| 5243 | } | ||
| 5244 | |||
| 5245 |
4/4✓ Branch 0 taken 1999 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1999 times.
|
3999 | if ((mi != nullptr) && |
| 5246 |
3/4✓ Branch 0 taken 1999 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1998 times.
|
1999 | mi->rli->m_assign_gtids_to_anonymous_transactions_info.get_type() > |
| 5247 | Assign_gtids_to_anonymous_transactions_info::enum_type::AGAT_OFF) { | ||
| 5248 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_error(ER_CANT_SET_ANONYMOUS_TO_GTID_AND_WAIT_UNTIL_SQL_THD_AFTER_GTIDS, |
| 5249 | MYF(0)); | ||
| 5250 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | channel_map.unlock(); |
| 5251 | 1 | return error_int(); | |
| 5252 | } | ||
| 5253 |
3/4✓ Branch 0 taken 1999 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1998 times.
|
1999 | if (global_gtid_mode.get() == Gtid_mode::OFF) { |
| 5254 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | channel_map.unlock(); |
| 5255 | 1 | return error_int(); | |
| 5256 | } | ||
| 5257 |
1/2✓ Branch 0 taken 1998 times.
✗ Branch 1 not taken.
|
1998 | gtid_state->begin_gtid_wait(); |
| 5258 | |||
| 5259 |
1/2✓ Branch 0 taken 1998 times.
✗ Branch 1 not taken.
|
1998 | if (mi != nullptr) mi->inc_reference(); |
| 5260 | |||
| 5261 |
1/2✓ Branch 0 taken 1998 times.
✗ Branch 1 not taken.
|
1998 | channel_map.unlock(); |
| 5262 | |||
| 5263 | 1998 | bool null_result = false; | |
| 5264 | |||
| 5265 |
2/4✓ Branch 0 taken 1998 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1998 times.
✗ Branch 3 not taken.
|
1998 | if (mi != nullptr && mi->rli != nullptr) { |
| 5266 |
1/2✓ Branch 0 taken 1998 times.
✗ Branch 1 not taken.
|
1998 | event_count = mi->rli->wait_for_gtid_set(thd, gtid, timeout); |
| 5267 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1997 times.
|
1998 | if (event_count == -2) { |
| 5268 | 1 | null_result = true; | |
| 5269 | } | ||
| 5270 | } else { | ||
| 5271 | /* | ||
| 5272 | Replication has not been set up, we should return NULL; | ||
| 5273 | */ | ||
| 5274 | ✗ | null_result = true; | |
| 5275 | } | ||
| 5276 |
1/2✓ Branch 0 taken 1998 times.
✗ Branch 1 not taken.
|
1998 | if (mi != nullptr) mi->dec_reference(); |
| 5277 | |||
| 5278 |
1/2✓ Branch 0 taken 1998 times.
✗ Branch 1 not taken.
|
1998 | gtid_state->end_gtid_wait(); |
| 5279 | |||
| 5280 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1997 times.
|
1998 | return null_result ? error_int() : event_count; |
| 5281 | 2007 | } | |
| 5282 | |||
| 5283 | /** | ||
| 5284 | Return 1 if both arguments are Gtid_sets and the first is a subset | ||
| 5285 | of the second. Generate an error if any of the arguments is not a | ||
| 5286 | Gtid_set. | ||
| 5287 | */ | ||
| 5288 | 5914 | longlong Item_func_gtid_subset::val_int() { | |
| 5289 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | DBUG_TRACE; |
| 5290 | |||
| 5291 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5914 times.
|
5914 | assert(fixed); |
| 5292 | |||
| 5293 | 5914 | null_value = false; | |
| 5294 | |||
| 5295 | // Evaluate strings without lock | ||
| 5296 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | String *string1 = args[0]->val_str(&buf1); |
| 5297 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5914 times.
|
5914 | if (string1 == nullptr) { |
| 5298 | ✗ | return error_int(); | |
| 5299 | } | ||
| 5300 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | String *string2 = args[1]->val_str(&buf2); |
| 5301 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5914 times.
|
5914 | if (string2 == nullptr) { |
| 5302 | ✗ | return error_int(); | |
| 5303 | } | ||
| 5304 | |||
| 5305 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | const char *charp1 = string1->c_ptr_safe(); |
| 5306 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5914 times.
|
5914 | assert(charp1 != nullptr); |
| 5307 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | const char *charp2 = string2->c_ptr_safe(); |
| 5308 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5914 times.
|
5914 | assert(charp2 != nullptr); |
| 5309 | 5914 | int ret = 1; | |
| 5310 | enum_return_status status; | ||
| 5311 | |||
| 5312 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | Sid_map sid_map(nullptr /*no rwlock*/); |
| 5313 | // compute sets while holding locks | ||
| 5314 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | const Gtid_set sub_set(&sid_map, charp1, &status); |
| 5315 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | if (status == RETURN_STATUS_OK) { |
| 5316 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | const Gtid_set super_set(&sid_map, charp2, &status); |
| 5317 |
1/2✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
|
5914 | if (status == RETURN_STATUS_OK) { |
| 5318 |
3/4✓ Branch 0 taken 5914 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5907 times.
✓ Branch 3 taken 7 times.
|
5914 | ret = sub_set.is_subset(&super_set) ? 1 : 0; |
| 5319 | } | ||
| 5320 | 5914 | } | |
| 5321 | 5914 | return ret; | |
| 5322 | 5914 | } | |
| 5323 | |||
| 5324 | /** | ||
| 5325 | Enables a session to wait on a condition until a timeout or a network | ||
| 5326 | disconnect occurs. | ||
| 5327 | |||
| 5328 | @remark The connection is polled every m_interrupt_interval nanoseconds. | ||
| 5329 | */ | ||
| 5330 | |||
| 5331 | class Interruptible_wait { | ||
| 5332 | THD *m_thd; | ||
| 5333 | struct timespec m_abs_timeout; | ||
| 5334 | static const ulonglong m_interrupt_interval; | ||
| 5335 | |||
| 5336 | public: | ||
| 5337 | 10696 | Interruptible_wait(THD *thd) : m_thd(thd) {} | |
| 5338 | |||
| 5339 | ~Interruptible_wait() = default; | ||
| 5340 | |||
| 5341 | public: | ||
| 5342 | /** | ||
| 5343 | Set the absolute timeout. | ||
| 5344 | |||
| 5345 | @param timeout The amount of time in nanoseconds to wait | ||
| 5346 | */ | ||
| 5347 | 10683 | void set_timeout(ulonglong timeout) { | |
| 5348 | /* | ||
| 5349 | Calculate the absolute system time at the start so it can | ||
| 5350 | be controlled in slices. It relies on the fact that once | ||
| 5351 | the absolute time passes, the timed wait call will fail | ||
| 5352 | automatically with a timeout error. | ||
| 5353 | */ | ||
| 5354 | 10683 | set_timespec_nsec(&m_abs_timeout, timeout); | |
| 5355 | 10683 | } | |
| 5356 | |||
| 5357 | /** The timed wait. */ | ||
| 5358 | int wait(mysql_cond_t *, mysql_mutex_t *); | ||
| 5359 | }; | ||
| 5360 | |||
| 5361 | /** Time to wait before polling the connection status. */ | ||
| 5362 | const ulonglong Interruptible_wait::m_interrupt_interval = 5 * 1000000000ULL; | ||
| 5363 | |||
| 5364 | /** | ||
| 5365 | Wait for a given condition to be signaled. | ||
| 5366 | |||
| 5367 | @param cond The condition variable to wait on. | ||
| 5368 | @param mutex The associated mutex. | ||
| 5369 | |||
| 5370 | @remark The absolute timeout is preserved across calls. | ||
| 5371 | |||
| 5372 | @retval return value from mysql_cond_timedwait | ||
| 5373 | */ | ||
| 5374 | |||
| 5375 | 10713 | int Interruptible_wait::wait(mysql_cond_t *cond, mysql_mutex_t *mutex) { | |
| 5376 | int error; | ||
| 5377 | struct timespec timeout; | ||
| 5378 | |||
| 5379 | while (true) { | ||
| 5380 | /* Wait for a fixed interval. */ | ||
| 5381 |
1/2✓ Branch 0 taken 10713 times.
✗ Branch 1 not taken.
|
10713 | set_timespec_nsec(&timeout, m_interrupt_interval); |
| 5382 | |||
| 5383 | /* But only if not past the absolute timeout. */ | ||
| 5384 |
2/2✓ Branch 0 taken 10657 times.
✓ Branch 1 taken 56 times.
|
10713 | if (cmp_timespec(&timeout, &m_abs_timeout) > 0) timeout = m_abs_timeout; |
| 5385 | |||
| 5386 |
1/2✓ Branch 0 taken 10684 times.
✗ Branch 1 not taken.
|
10713 | error = mysql_cond_timedwait(cond, mutex, &timeout); |
| 5387 |
2/2✓ Branch 0 taken 10652 times.
✓ Branch 1 taken 32 times.
|
10684 | if (is_timeout(error)) { |
| 5388 | /* Return error if timed out or connection is broken. */ | ||
| 5389 |
7/8✓ Branch 0 taken 36 times.
✓ Branch 1 taken 10616 times.
✓ Branch 2 taken 36 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 30 times.
✓ Branch 6 taken 10622 times.
✓ Branch 7 taken 30 times.
|
10652 | if (!cmp_timespec(&timeout, &m_abs_timeout) || !m_thd->is_connected()) |
| 5390 | 10622 | break; | |
| 5391 | } | ||
| 5392 | /* Otherwise, propagate status to the caller. */ | ||
| 5393 | else | ||
| 5394 | 32 | break; | |
| 5395 | } | ||
| 5396 | |||
| 5397 | 10654 | return error; | |
| 5398 | } | ||
| 5399 | |||
| 5400 | /* | ||
| 5401 | User-level locks implementation. | ||
| 5402 | */ | ||
| 5403 | |||
| 5404 | /** | ||
| 5405 | For locks with EXPLICIT duration, MDL returns a new ticket | ||
| 5406 | every time a lock is granted. This allows to implement recursive | ||
| 5407 | locks without extra allocation or additional data structures, such | ||
| 5408 | as below. However, if there are too many tickets in the same | ||
| 5409 | MDL_context, MDL_context::find_ticket() is getting too slow, | ||
| 5410 | since it's using a linear search. | ||
| 5411 | This is why a separate structure is allocated for a user | ||
| 5412 | level lock held by connection, and before requesting a new lock from MDL, | ||
| 5413 | GET_LOCK() checks thd->ull_hash if such lock is already granted, | ||
| 5414 | and if so, simply increments a reference counter. | ||
| 5415 | */ | ||
| 5416 | |||
| 5417 | struct User_level_lock { | ||
| 5418 | MDL_ticket *ticket; | ||
| 5419 | uint refs; | ||
| 5420 | }; | ||
| 5421 | |||
| 5422 | /** | ||
| 5423 | Release all user level locks for this THD. | ||
| 5424 | */ | ||
| 5425 | |||
| 5426 | 1144278 | void mysql_ull_cleanup(THD *thd) { | |
| 5427 |
1/2✓ Branch 0 taken 1144750 times.
✗ Branch 1 not taken.
|
1144278 | DBUG_TRACE; |
| 5428 | |||
| 5429 |
2/2✓ Branch 0 taken 64 times.
✓ Branch 1 taken 1144000 times.
|
1144814 | for (const auto &key_and_value : thd->ull_hash) { |
| 5430 | 64 | User_level_lock *ull = key_and_value.second; | |
| 5431 |
1/2✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
|
64 | thd->mdl_context.release_lock(ull->ticket); |
| 5432 |
1/2✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
|
64 | my_free(ull); |
| 5433 | } | ||
| 5434 | |||
| 5435 | 1144000 | thd->ull_hash.clear(); | |
| 5436 | 1144457 | } | |
| 5437 | |||
| 5438 | /** | ||
| 5439 | Set explicit duration for metadata locks corresponding to | ||
| 5440 | user level locks to protect them from being released at the end | ||
| 5441 | of transaction. | ||
| 5442 | */ | ||
| 5443 | |||
| 5444 | 2 | void mysql_ull_set_explicit_lock_duration(THD *thd) { | |
| 5445 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | DBUG_TRACE; |
| 5446 | |||
| 5447 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
|
5 | for (const auto &key_and_value : thd->ull_hash) { |
| 5448 | 3 | User_level_lock *ull = key_and_value.second; | |
| 5449 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | thd->mdl_context.set_lock_duration(ull->ticket, MDL_EXPLICIT); |
| 5450 | } | ||
| 5451 | 2 | } | |
| 5452 | |||
| 5453 | /** | ||
| 5454 | When MDL detects a lock wait timeout, it pushes an error into the statement | ||
| 5455 | diagnostics area. For GET_LOCK(), lock wait timeout is not an error, but a | ||
| 5456 | special return value (0). NULL is returned in case of error. Capture and | ||
| 5457 | suppress lock wait timeout. | ||
| 5458 | We also convert ER_LOCK_DEADLOCK error to ER_USER_LOCK_DEADLOCK error. | ||
| 5459 | The former means that implicit rollback of transaction has occurred | ||
| 5460 | which doesn't (and should not) happen when we get deadlock while waiting | ||
| 5461 | for user-level lock. | ||
| 5462 | */ | ||
| 5463 | |||
| 5464 | class User_level_lock_wait_error_handler : public Internal_error_handler { | ||
| 5465 | public: | ||
| 5466 | 6510 | User_level_lock_wait_error_handler() : m_lock_wait_timeout(false) {} | |
| 5467 | |||
| 5468 | 28 | bool got_timeout() const { return m_lock_wait_timeout; } | |
| 5469 | |||
| 5470 | 32 | bool handle_condition(THD *, uint sql_errno, const char *, | |
| 5471 | Sql_condition::enum_severity_level *, | ||
| 5472 | const char *) override { | ||
| 5473 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 18 times.
|
32 | if (sql_errno == ER_LOCK_WAIT_TIMEOUT) { |
| 5474 | 14 | m_lock_wait_timeout = true; | |
| 5475 | 14 | return true; | |
| 5476 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 14 times.
|
18 | } else if (sql_errno == ER_LOCK_DEADLOCK) { |
| 5477 | 4 | my_error(ER_USER_LOCK_DEADLOCK, MYF(0)); | |
| 5478 | 4 | return true; | |
| 5479 | } | ||
| 5480 | |||
| 5481 | 14 | return false; | |
| 5482 | } | ||
| 5483 | |||
| 5484 | private: | ||
| 5485 | bool m_lock_wait_timeout; | ||
| 5486 | }; | ||
| 5487 | |||
| 5488 | class MDL_lock_get_owner_thread_id_visitor : public MDL_context_visitor { | ||
| 5489 | public: | ||
| 5490 | 125 | MDL_lock_get_owner_thread_id_visitor() : m_owner_id(0) {} | |
| 5491 | |||
| 5492 | 59 | void visit_context(const MDL_context *ctx) override { | |
| 5493 | 59 | m_owner_id = ctx->get_owner()->get_thd()->thread_id(); | |
| 5494 | 59 | } | |
| 5495 | |||
| 5496 | 125 | my_thread_id get_owner_id() const { return m_owner_id; } | |
| 5497 | |||
| 5498 | private: | ||
| 5499 | my_thread_id m_owner_id; | ||
| 5500 | }; | ||
| 5501 | |||
| 5502 | /** | ||
| 5503 | Helper function which checks if user-level lock name is acceptable | ||
| 5504 | and converts it to system charset (utf8). Error is emitted if name | ||
| 5505 | is not acceptable. Name is also lowercased to ensure that user-level | ||
| 5506 | lock names are treated in case-insensitive fashion even though MDL | ||
| 5507 | subsystem which used by implementation does binary comparison of keys. | ||
| 5508 | |||
| 5509 | @param buff Buffer for lowercased name in system charset of | ||
| 5510 | NAME_LEN + 1 bytes length. | ||
| 5511 | @param org_name Original string passed as name parameter to | ||
| 5512 | user-level lock function. | ||
| 5513 | |||
| 5514 | @return True in case of error, false on success. | ||
| 5515 | */ | ||
| 5516 | |||
| 5517 | 13085 | static bool check_and_convert_ull_name(char *buff, const String *org_name) { | |
| 5518 |
6/6✓ Branch 0 taken 13080 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 13076 times.
✓ Branch 4 taken 9 times.
✓ Branch 5 taken 13076 times.
|
13085 | if (!org_name || !org_name->length()) { |
| 5519 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
|
9 | my_error(ER_USER_LOCK_WRONG_NAME, MYF(0), (org_name ? "" : "NULL")); |
| 5520 | 9 | return true; | |
| 5521 | } | ||
| 5522 | |||
| 5523 | const char *well_formed_error_pos; | ||
| 5524 | const char *cannot_convert_error_pos; | ||
| 5525 | const char *from_end_pos; | ||
| 5526 | size_t bytes_copied; | ||
| 5527 | |||
| 5528 |
1/2✓ Branch 0 taken 13076 times.
✗ Branch 1 not taken.
|
13076 | bytes_copied = well_formed_copy_nchars( |
| 5529 | system_charset_info, buff, NAME_LEN, org_name->charset(), org_name->ptr(), | ||
| 5530 | org_name->length(), NAME_CHAR_LEN, &well_formed_error_pos, | ||
| 5531 | &cannot_convert_error_pos, &from_end_pos); | ||
| 5532 | |||
| 5533 |
5/6✓ Branch 0 taken 13075 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 13075 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 13071 times.
|
26151 | if (well_formed_error_pos || cannot_convert_error_pos || |
| 5534 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 13071 times.
|
13075 | from_end_pos < org_name->ptr() + org_name->length()) { |
| 5535 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | ErrConvString err(org_name); |
| 5536 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | my_error(ER_USER_LOCK_WRONG_NAME, MYF(0), err.ptr()); |
| 5537 | 5 | return true; | |
| 5538 | } | ||
| 5539 | |||
| 5540 | 13071 | buff[bytes_copied] = '\0'; | |
| 5541 | |||
| 5542 |
1/2✓ Branch 0 taken 13071 times.
✗ Branch 1 not taken.
|
13071 | my_casedn_str(system_charset_info, buff); |
| 5543 | |||
| 5544 | 13071 | return false; | |
| 5545 | } | ||
| 5546 | |||
| 5547 | 7104 | bool Item_func_get_lock::itemize(Parse_context *pc, Item **res) { | |
| 5548 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7105 times.
|
7104 | if (skip_itemize(res)) return false; |
| 5549 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7105 times.
|
7105 | if (super::itemize(pc, res)) return true; |
| 5550 | 7105 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 5551 | 7105 | pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT); | |
| 5552 | 7105 | return false; | |
| 5553 | } | ||
| 5554 | |||
| 5555 | /** | ||
| 5556 | Get a user level lock. | ||
| 5557 | |||
| 5558 | @note Sets null_value to true on error. | ||
| 5559 | |||
| 5560 | @note This means that SQL-function GET_LOCK() returns: | ||
| 5561 | 1 - if lock was acquired. | ||
| 5562 | 0 - if lock was not acquired due to timeout. | ||
| 5563 | NULL - in case of error such as bad lock name, deadlock, | ||
| 5564 | thread being killed (also error is emitted). | ||
| 5565 | |||
| 5566 | @retval | ||
| 5567 | 1 : Got lock | ||
| 5568 | @retval | ||
| 5569 | 0 : Timeout, error. | ||
| 5570 | */ | ||
| 5571 | |||
| 5572 | 6559 | longlong Item_func_get_lock::val_int() { | |
| 5573 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6559 times.
|
6559 | assert(fixed == 1); |
| 5574 |
1/2✓ Branch 0 taken 6559 times.
✗ Branch 1 not taken.
|
6559 | String *res = args[0]->val_str(&value); |
| 5575 |
1/2✓ Branch 0 taken 6559 times.
✗ Branch 1 not taken.
|
6559 | ulonglong timeout = args[1]->val_int(); |
| 5576 | char name[NAME_LEN + 1]; | ||
| 5577 |
1/2✓ Branch 0 taken 6559 times.
✗ Branch 1 not taken.
|
6559 | THD *thd = current_thd; |
| 5578 |
1/2✓ Branch 0 taken 6559 times.
✗ Branch 1 not taken.
|
6559 | DBUG_TRACE; |
| 5579 | |||
| 5580 | 6559 | null_value = true; | |
| 5581 | |||
| 5582 | #ifdef WITH_WSREP | ||
| 5583 | 6559 | bool block = false; | |
| 5584 | |||
| 5585 |
3/3✓ Branch 0 taken 6557 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
|
6559 | switch (pxc_strict_mode) { |
| 5586 | 6557 | case PXC_STRICT_MODE_DISABLED: | |
| 5587 | case PXC_STRICT_MODE_MASTER: | ||
| 5588 | /* Do nothing */ | ||
| 5589 | 6557 | break; | |
| 5590 | 1 | case PXC_STRICT_MODE_PERMISSIVE: | |
| 5591 |
10/22✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 1 times.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✓ Branch 19 taken 1 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
|
1 | WSREP_WARN( |
| 5592 | "Percona-XtraDB-Cluster doesn't recommend use of" | ||
| 5593 | " GET_LOCK with pxc_strict_mode = PERMISSIVE"); | ||
| 5594 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | push_warning_printf(thd, Sql_condition::SL_WARNING, ER_UNKNOWN_ERROR, |
| 5595 | "Percona-XtraDB-Cluster doesn't recommend use of" | ||
| 5596 | " GET_LOCK with pxc_strict_mode = PERMISSIVE"); | ||
| 5597 | 1 | break; | |
| 5598 | 1 | case PXC_STRICT_MODE_ENFORCING: | |
| 5599 | default: | ||
| 5600 | 1 | block = true; | |
| 5601 |
13/28✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 1 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 1 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 1 times.
✗ Branch 21 not taken.
✓ Branch 22 taken 1 times.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✓ Branch 25 taken 1 times.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
|
1 | WSREP_ERROR( |
| 5602 | "Percona-XtraDB-Cluster prohibits use of GET_LOCK" | ||
| 5603 | " with pxc_strict_mode = ENFORCING"); | ||
| 5604 | char message[1024]; | ||
| 5605 | 1 | sprintf(message, | |
| 5606 | "Percona-XtraDB-Cluster prohibits use of GET_LOCK" | ||
| 5607 | " with pxc_strict_mode = ENFORCING"); | ||
| 5608 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_message(ER_UNKNOWN_ERROR, message, MYF(0)); |
| 5609 | 1 | break; | |
| 5610 | } | ||
| 5611 | |||
| 5612 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6558 times.
|
6559 | if (block) return 0; |
| 5613 | #endif /* WITH_WSREP */ | ||
| 5614 | |||
| 5615 | /* | ||
| 5616 | In slave thread no need to get locks, everything is serialized. Anyway | ||
| 5617 | there is no way to make GET_LOCK() work on slave like it did on master | ||
| 5618 | (i.e. make it return exactly the same value) because we don't have the | ||
| 5619 | same other concurrent threads environment. No matter what we return here, | ||
| 5620 | it's not guaranteed to be same as on master. So we always return 1. | ||
| 5621 | */ | ||
| 5622 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 6545 times.
|
6558 | if (thd->slave_thread) { |
| 5623 | 13 | null_value = false; | |
| 5624 | 13 | return 1; | |
| 5625 | } | ||
| 5626 | |||
| 5627 |
3/4✓ Branch 0 taken 6545 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 6542 times.
|
6545 | if (check_and_convert_ull_name(name, res)) return 0; |
| 5628 | |||
| 5629 |
3/8✓ Branch 0 taken 6542 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6542 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6542 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
6542 | DBUG_PRINT("info", ("lock %s, thd=%lu", name, (ulong)thd->real_id)); |
| 5630 | |||
| 5631 | /* | ||
| 5632 | Convert too big and negative timeout values to INT_MAX32. | ||
| 5633 | This gives robust, "infinite" wait on all platforms. | ||
| 5634 | */ | ||
| 5635 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6541 times.
|
6542 | if (timeout > INT_MAX32) timeout = INT_MAX32; |
| 5636 | |||
| 5637 | 6542 | MDL_request ull_request; | |
| 5638 |
1/2✓ Branch 0 taken 6542 times.
✗ Branch 1 not taken.
|
6542 | MDL_REQUEST_INIT(&ull_request, MDL_key::USER_LEVEL_LOCK, "", name, |
| 5639 | MDL_EXCLUSIVE, MDL_EXPLICIT); | ||
| 5640 | 13084 | std::string ull_key(pointer_cast<const char *>(ull_request.key.ptr()), | |
| 5641 |
2/4✓ Branch 0 taken 6542 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6542 times.
✗ Branch 3 not taken.
|
13084 | ull_request.key.length()); |
| 5642 | |||
| 5643 |
1/2✓ Branch 0 taken 6542 times.
✗ Branch 1 not taken.
|
6542 | const auto it = thd->ull_hash.find(ull_key); |
| 5644 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 6510 times.
|
6542 | if (it != thd->ull_hash.end()) { |
| 5645 | /* Recursive lock. */ | ||
| 5646 | 32 | it->second->refs++; | |
| 5647 | 32 | null_value = false; | |
| 5648 | 32 | return 1; | |
| 5649 | } | ||
| 5650 | |||
| 5651 | 13020 | User_level_lock_wait_error_handler error_handler; | |
| 5652 | |||
| 5653 |
1/2✓ Branch 0 taken 6510 times.
✗ Branch 1 not taken.
|
6510 | thd->push_internal_handler(&error_handler); |
| 5654 | bool error = | ||
| 5655 |
1/2✓ Branch 0 taken 6510 times.
✗ Branch 1 not taken.
|
6510 | thd->mdl_context.acquire_lock(&ull_request, static_cast<ulong>(timeout)); |
| 5656 |
1/2✓ Branch 0 taken 6510 times.
✗ Branch 1 not taken.
|
6510 | (void)thd->pop_internal_handler(); |
| 5657 | |||
| 5658 |
2/2✓ Branch 0 taken 28 times.
✓ Branch 1 taken 6482 times.
|
6510 | if (error) { |
| 5659 | /* | ||
| 5660 | Return 0 in case of timeout and NULL in case of deadlock/other | ||
| 5661 | errors. In the latter case error (e.g. ER_USER_LOCK_DEADLOCK) | ||
| 5662 | will be reported as well. | ||
| 5663 | */ | ||
| 5664 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 14 times.
|
28 | if (error_handler.got_timeout()) null_value = false; |
| 5665 | 28 | return 0; | |
| 5666 | } | ||
| 5667 | |||
| 5668 | 6482 | User_level_lock *ull = nullptr; | |
| 5669 | 6482 | ull = reinterpret_cast<User_level_lock *>( | |
| 5670 |
1/2✓ Branch 0 taken 6482 times.
✗ Branch 1 not taken.
|
6482 | my_malloc(key_memory_User_level_lock, sizeof(User_level_lock), MYF(0))); |
| 5671 | |||
| 5672 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6482 times.
|
6482 | if (ull == nullptr) { |
| 5673 | ✗ | thd->mdl_context.release_lock(ull_request.ticket); | |
| 5674 | ✗ | return 0; | |
| 5675 | } | ||
| 5676 | |||
| 5677 | 6482 | ull->ticket = ull_request.ticket; | |
| 5678 | 6482 | ull->refs = 1; | |
| 5679 | |||
| 5680 |
1/2✓ Branch 0 taken 6482 times.
✗ Branch 1 not taken.
|
6482 | thd->ull_hash.emplace(ull_key, ull); |
| 5681 | 6482 | null_value = false; | |
| 5682 | |||
| 5683 | 6482 | return 1; | |
| 5684 | 6559 | } | |
| 5685 | |||
| 5686 | 6954 | bool Item_func_release_lock::itemize(Parse_context *pc, Item **res) { | |
| 5687 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6954 times.
|
6954 | if (skip_itemize(res)) return false; |
| 5688 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6954 times.
|
6954 | if (super::itemize(pc, res)) return true; |
| 5689 | 6954 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 5690 | 6954 | pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT); | |
| 5691 | 6954 | return false; | |
| 5692 | } | ||
| 5693 | |||
| 5694 | /** | ||
| 5695 | Release a user level lock. | ||
| 5696 | |||
| 5697 | @note Sets null_value to true on error/if no connection holds such lock. | ||
| 5698 | |||
| 5699 | @note This means that SQL-function RELEASE_LOCK() returns: | ||
| 5700 | 1 - if lock was held by this connection and was released. | ||
| 5701 | 0 - if lock was held by some other connection (and was not released). | ||
| 5702 | NULL - if name of lock is bad or if it was not held by any connection | ||
| 5703 | (in the former case also error will be emitted), | ||
| 5704 | |||
| 5705 | @return | ||
| 5706 | - 1 if lock released | ||
| 5707 | - 0 if lock wasn't held/error. | ||
| 5708 | */ | ||
| 5709 | |||
| 5710 | 6420 | longlong Item_func_release_lock::val_int() { | |
| 5711 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6420 times.
|
6420 | assert(fixed == 1); |
| 5712 |
1/2✓ Branch 0 taken 6420 times.
✗ Branch 1 not taken.
|
6420 | String *res = args[0]->val_str(&value); |
| 5713 | char name[NAME_LEN + 1]; | ||
| 5714 |
1/2✓ Branch 0 taken 6420 times.
✗ Branch 1 not taken.
|
6420 | THD *thd = current_thd; |
| 5715 |
1/2✓ Branch 0 taken 6420 times.
✗ Branch 1 not taken.
|
6420 | DBUG_TRACE; |
| 5716 | |||
| 5717 | 6420 | null_value = true; | |
| 5718 | |||
| 5719 | #ifdef WITH_WSREP | ||
| 5720 | 6420 | bool block = false; | |
| 5721 | |||
| 5722 |
3/3✓ Branch 0 taken 6418 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
|
6420 | switch (pxc_strict_mode) { |
| 5723 | 6418 | case PXC_STRICT_MODE_DISABLED: | |
| 5724 | case PXC_STRICT_MODE_MASTER: | ||
| 5725 | /* Do nothing */ | ||
| 5726 | 6418 | break; | |
| 5727 | 1 | case PXC_STRICT_MODE_PERMISSIVE: | |
| 5728 |
10/22✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 1 times.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✓ Branch 19 taken 1 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
|
1 | WSREP_WARN( |
| 5729 | "Percona-XtraDB-Cluster doesn't recommend use of" | ||
| 5730 | " RELEASE_LOCK with pxc_strict_mode = PERMISSIVE"); | ||
| 5731 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | push_warning_printf(thd, Sql_condition::SL_WARNING, ER_UNKNOWN_ERROR, |
| 5732 | "Percona-XtraDB-Cluster doesn't recommend use of" | ||
| 5733 | " RELEASE_LOCK with pxc_strict_mode = PERMISSIVE"); | ||
| 5734 | 1 | break; | |
| 5735 | 1 | case PXC_STRICT_MODE_ENFORCING: | |
| 5736 | default: | ||
| 5737 | 1 | block = true; | |
| 5738 |
13/28✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 1 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 1 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 1 times.
✗ Branch 21 not taken.
✓ Branch 22 taken 1 times.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✓ Branch 25 taken 1 times.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
|
1 | WSREP_ERROR( |
| 5739 | "Percona-XtraDB-Cluster prohibits use of RELEASE_LOCK" | ||
| 5740 | " with pxc_strict_mode = ENFORCING"); | ||
| 5741 | char message[1024]; | ||
| 5742 | 1 | sprintf(message, | |
| 5743 | "Percona-XtraDB-Cluster prohibits use of RELEASE_LOCK" | ||
| 5744 | " with pxc_strict_mode = ENFORCING"); | ||
| 5745 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_message(ER_UNKNOWN_ERROR, message, MYF(0)); |
| 5746 | 1 | break; | |
| 5747 | } | ||
| 5748 | |||
| 5749 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6419 times.
|
6420 | if (block) return 0; |
| 5750 | #endif /* WITH_WSREP */ | ||
| 5751 | |||
| 5752 |
3/4✓ Branch 0 taken 6419 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 6415 times.
|
6419 | if (check_and_convert_ull_name(name, res)) return 0; |
| 5753 | |||
| 5754 |
3/8✓ Branch 0 taken 6415 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6415 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6415 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
6415 | DBUG_PRINT("info", ("lock %s", name)); |
| 5755 | |||
| 5756 | 6415 | MDL_key ull_key; | |
| 5757 |
1/2✓ Branch 0 taken 6415 times.
✗ Branch 1 not taken.
|
6415 | ull_key.mdl_key_init(MDL_key::USER_LEVEL_LOCK, "", name); |
| 5758 | |||
| 5759 |
1/2✓ Branch 0 taken 6415 times.
✗ Branch 1 not taken.
|
6415 | const auto it = thd->ull_hash.find( |
| 5760 |
2/4✓ Branch 0 taken 6415 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6415 times.
✗ Branch 3 not taken.
|
12830 | std::string(pointer_cast<const char *>(ull_key.ptr()), ull_key.length())); |
| 5761 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 6404 times.
|
6415 | if (it == thd->ull_hash.end()) { |
| 5762 | /* | ||
| 5763 | When RELEASE_LOCK() is called for lock which is not owned by the | ||
| 5764 | connection it should return 0 or NULL depending on whether lock | ||
| 5765 | is owned by any other connection or not. | ||
| 5766 | */ | ||
| 5767 | 11 | MDL_lock_get_owner_thread_id_visitor get_owner_visitor; | |
| 5768 | |||
| 5769 |
2/4✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
|
11 | if (thd->mdl_context.find_lock_owner(&ull_key, &get_owner_visitor)) |
| 5770 | ✗ | return 0; | |
| 5771 | |||
| 5772 | 11 | null_value = get_owner_visitor.get_owner_id() == 0; | |
| 5773 | |||
| 5774 | 11 | return 0; | |
| 5775 | 11 | } | |
| 5776 | 6404 | User_level_lock *ull = it->second; | |
| 5777 | |||
| 5778 | 6404 | null_value = false; | |
| 5779 |
2/2✓ Branch 0 taken 6393 times.
✓ Branch 1 taken 11 times.
|
6404 | if (--ull->refs == 0) { |
| 5780 |
1/2✓ Branch 0 taken 6393 times.
✗ Branch 1 not taken.
|
6393 | thd->ull_hash.erase(it); |
| 5781 |
1/2✓ Branch 0 taken 6393 times.
✗ Branch 1 not taken.
|
6393 | thd->mdl_context.release_lock(ull->ticket); |
| 5782 |
1/2✓ Branch 0 taken 6393 times.
✗ Branch 1 not taken.
|
6393 | my_free(ull); |
| 5783 | } | ||
| 5784 | 6404 | return 1; | |
| 5785 | 6420 | } | |
| 5786 | |||
| 5787 | 33 | bool Item_func_release_all_locks::itemize(Parse_context *pc, Item **res) { | |
| 5788 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 33 times.
|
33 | if (skip_itemize(res)) return false; |
| 5789 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 33 times.
|
33 | if (super::itemize(pc, res)) return true; |
| 5790 | 33 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 5791 | 33 | pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT); | |
| 5792 | 33 | return false; | |
| 5793 | } | ||
| 5794 | |||
| 5795 | /** | ||
| 5796 | Release all user level lock held by connection. | ||
| 5797 | |||
| 5798 | @return Number of locks released including recursive lock count. | ||
| 5799 | */ | ||
| 5800 | |||
| 5801 | 29 | longlong Item_func_release_all_locks::val_int() { | |
| 5802 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29 times.
|
29 | assert(fixed == 1); |
| 5803 |
1/2✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
|
29 | THD *thd = current_thd; |
| 5804 | 29 | uint result = 0; | |
| 5805 |
1/2✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
|
29 | DBUG_TRACE; |
| 5806 | |||
| 5807 |
2/2✓ Branch 0 taken 25 times.
✓ Branch 1 taken 29 times.
|
54 | for (const auto &key_and_value : thd->ull_hash) { |
| 5808 | 25 | User_level_lock *ull = key_and_value.second; | |
| 5809 |
1/2✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
|
25 | thd->mdl_context.release_lock(ull->ticket); |
| 5810 | 25 | result += ull->refs; | |
| 5811 |
1/2✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
|
25 | my_free(ull); |
| 5812 | } | ||
| 5813 | 29 | thd->ull_hash.clear(); | |
| 5814 | |||
| 5815 | 29 | return result; | |
| 5816 | 29 | } | |
| 5817 | |||
| 5818 | 68 | bool Item_func_is_free_lock::itemize(Parse_context *pc, Item **res) { | |
| 5819 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 68 times.
|
68 | if (skip_itemize(res)) return false; |
| 5820 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 68 times.
|
68 | if (super::itemize(pc, res)) return true; |
| 5821 | 68 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 5822 | 68 | pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT); | |
| 5823 | 68 | return false; | |
| 5824 | } | ||
| 5825 | |||
| 5826 | /** | ||
| 5827 | Check if user level lock is free. | ||
| 5828 | |||
| 5829 | @note Sets null_value=true on error. | ||
| 5830 | |||
| 5831 | @note As result SQL-function IS_FREE_LOCK() returns: | ||
| 5832 | 1 - if lock is free, | ||
| 5833 | 0 - if lock is in use | ||
| 5834 | NULL - if lock name is bad or OOM (also error is emitted). | ||
| 5835 | |||
| 5836 | @retval | ||
| 5837 | 1 Available | ||
| 5838 | @retval | ||
| 5839 | 0 Already taken, or error | ||
| 5840 | */ | ||
| 5841 | |||
| 5842 | 62 | longlong Item_func_is_free_lock::val_int() { | |
| 5843 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
|
62 | assert(fixed == 1); |
| 5844 | 62 | value.length(0); | |
| 5845 |
1/2✓ Branch 0 taken 62 times.
✗ Branch 1 not taken.
|
62 | String *res = args[0]->val_str(&value); |
| 5846 | char name[NAME_LEN + 1]; | ||
| 5847 |
1/2✓ Branch 0 taken 62 times.
✗ Branch 1 not taken.
|
62 | THD *thd = current_thd; |
| 5848 | |||
| 5849 | 62 | null_value = true; | |
| 5850 | |||
| 5851 |
3/4✓ Branch 0 taken 62 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 58 times.
|
62 | if (check_and_convert_ull_name(name, res)) return 0; |
| 5852 | |||
| 5853 | 58 | MDL_key ull_key; | |
| 5854 |
1/2✓ Branch 0 taken 58 times.
✗ Branch 1 not taken.
|
58 | ull_key.mdl_key_init(MDL_key::USER_LEVEL_LOCK, "", name); |
| 5855 | |||
| 5856 | 58 | MDL_lock_get_owner_thread_id_visitor get_owner_visitor; | |
| 5857 | |||
| 5858 |
2/4✓ Branch 0 taken 58 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 58 times.
|
58 | if (thd->mdl_context.find_lock_owner(&ull_key, &get_owner_visitor)) return 0; |
| 5859 | |||
| 5860 | 58 | null_value = false; | |
| 5861 | 58 | return (get_owner_visitor.get_owner_id() == 0); | |
| 5862 | 58 | } | |
| 5863 | |||
| 5864 | 586 | bool Item_func_is_used_lock::itemize(Parse_context *pc, Item **res) { | |
| 5865 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 586 times.
|
586 | if (skip_itemize(res)) return false; |
| 5866 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 586 times.
|
586 | if (super::itemize(pc, res)) return true; |
| 5867 | 586 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 5868 | 586 | pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT); | |
| 5869 | 586 | return false; | |
| 5870 | } | ||
| 5871 | |||
| 5872 | /** | ||
| 5873 | Check if user level lock is used and return connection id of owner. | ||
| 5874 | |||
| 5875 | @note Sets null_value=true if lock is free/on error. | ||
| 5876 | |||
| 5877 | @note SQL-function IS_USED_LOCK() returns: | ||
| 5878 | # - connection id of lock owner if lock is acquired. | ||
| 5879 | NULL - if lock is free or on error (in the latter case | ||
| 5880 | also error is emitted). | ||
| 5881 | |||
| 5882 | @return Connection id of lock owner, 0 if lock is free/on error. | ||
| 5883 | */ | ||
| 5884 | |||
| 5885 | 59 | longlong Item_func_is_used_lock::val_int() { | |
| 5886 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
|
59 | assert(fixed == 1); |
| 5887 |
1/2✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
|
59 | String *res = args[0]->val_str(&value); |
| 5888 | char name[NAME_LEN + 1]; | ||
| 5889 |
1/2✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
|
59 | THD *thd = current_thd; |
| 5890 | |||
| 5891 | 59 | null_value = true; | |
| 5892 | |||
| 5893 |
3/4✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 56 times.
|
59 | if (check_and_convert_ull_name(name, res)) return 0; |
| 5894 | |||
| 5895 | 56 | MDL_key ull_key; | |
| 5896 |
1/2✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
|
56 | ull_key.mdl_key_init(MDL_key::USER_LEVEL_LOCK, "", name); |
| 5897 | |||
| 5898 | 56 | MDL_lock_get_owner_thread_id_visitor get_owner_visitor; | |
| 5899 | |||
| 5900 |
2/4✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 56 times.
|
56 | if (thd->mdl_context.find_lock_owner(&ull_key, &get_owner_visitor)) return 0; |
| 5901 | |||
| 5902 | 56 | my_thread_id thread_id = get_owner_visitor.get_owner_id(); | |
| 5903 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 32 times.
|
56 | if (thread_id == 0) return 0; |
| 5904 | |||
| 5905 | 32 | null_value = false; | |
| 5906 | 32 | return thread_id; | |
| 5907 | 56 | } | |
| 5908 | |||
| 5909 | 1389 | bool Item_func_last_insert_id::itemize(Parse_context *pc, Item **res) { | |
| 5910 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1389 times.
|
1389 | if (skip_itemize(res)) return false; |
| 5911 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1389 times.
|
1389 | if (super::itemize(pc, res)) return true; |
| 5912 | 1389 | pc->thd->lex->safe_to_cache_query = false; | |
| 5913 | 1389 | pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT); | |
| 5914 | 1389 | return false; | |
| 5915 | } | ||
| 5916 | |||
| 5917 | 1862 | longlong Item_func_last_insert_id::val_int() { | |
| 5918 | 1862 | THD *thd = current_thd; | |
| 5919 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1862 times.
|
1862 | assert(fixed == 1); |
| 5920 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 1842 times.
|
1862 | if (arg_count) { |
| 5921 | 20 | longlong value = args[0]->val_int(); | |
| 5922 | 20 | null_value = args[0]->null_value; | |
| 5923 | /* | ||
| 5924 | LAST_INSERT_ID(X) must affect the client's mysql_insert_id() as | ||
| 5925 | documented in the manual. We don't want to touch | ||
| 5926 | first_successful_insert_id_in_cur_stmt because it would make | ||
| 5927 | LAST_INSERT_ID(X) take precedence over an generated auto_increment | ||
| 5928 | value for this row. | ||
| 5929 | */ | ||
| 5930 | 20 | thd->arg_of_last_insert_id_function = true; | |
| 5931 | 20 | thd->first_successful_insert_id_in_prev_stmt = value; | |
| 5932 | 20 | return value; | |
| 5933 | } | ||
| 5934 | return static_cast<longlong>( | ||
| 5935 | 1842 | thd->read_first_successful_insert_id_in_prev_stmt()); | |
| 5936 | } | ||
| 5937 | |||
| 5938 | 52 | bool Item_func_benchmark::itemize(Parse_context *pc, Item **res) { | |
| 5939 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 52 times.
|
52 | if (skip_itemize(res)) return false; |
| 5940 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 52 times.
|
52 | if (super::itemize(pc, res)) return true; |
| 5941 | 52 | pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT); | |
| 5942 | 52 | return false; | |
| 5943 | } | ||
| 5944 | |||
| 5945 | /* This function is just used to test speed of different functions */ | ||
| 5946 | |||
| 5947 | 32 | longlong Item_func_benchmark::val_int() { | |
| 5948 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | assert(fixed == 1); |
| 5949 | char buff[MAX_FIELD_WIDTH]; | ||
| 5950 | 32 | String tmp(buff, sizeof(buff), &my_charset_bin); | |
| 5951 | 32 | my_decimal tmp_decimal; | |
| 5952 |
1/2✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
|
32 | THD *thd = current_thd; |
| 5953 | ulonglong loop_count; | ||
| 5954 | |||
| 5955 |
1/2✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
|
32 | loop_count = (ulonglong)args[0]->val_int(); |
| 5956 | |||
| 5957 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 2 times.
|
32 | if (args[0]->null_value || |
| 5958 |
3/4✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 29 times.
|
30 | (!args[0]->unsigned_flag && (((longlong)loop_count) < 0))) { |
| 5959 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
|
3 | if (!args[0]->null_value) { |
| 5960 | char errbuff[22]; | ||
| 5961 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | llstr(((longlong)loop_count), errbuff); |
| 5962 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | push_warning_printf(current_thd, Sql_condition::SL_WARNING, |
| 5963 | ER_WRONG_VALUE_FOR_TYPE, | ||
| 5964 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | ER_THD(current_thd, ER_WRONG_VALUE_FOR_TYPE), "count", |
| 5965 | errbuff, "benchmark"); | ||
| 5966 | } | ||
| 5967 | |||
| 5968 | 3 | null_value = true; | |
| 5969 | 3 | return 0; | |
| 5970 | } | ||
| 5971 | |||
| 5972 | 29 | null_value = false; | |
| 5973 |
5/6✓ Branch 0 taken 1440 times.
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 1440 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1440 times.
✓ Branch 5 taken 29 times.
|
1469 | for (ulonglong loop = 0; loop < loop_count && !thd->killed; loop++) { |
| 5974 |
5/7✓ Branch 0 taken 1440 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 40 times.
✓ Branch 3 taken 1000 times.
✓ Branch 4 taken 100 times.
✓ Branch 5 taken 300 times.
✗ Branch 6 not taken.
|
1440 | switch (args[1]->result_type()) { |
| 5975 | 40 | case REAL_RESULT: | |
| 5976 |
1/2✓ Branch 0 taken 40 times.
✗ Branch 1 not taken.
|
40 | (void)args[1]->val_real(); |
| 5977 | 40 | break; | |
| 5978 | 1000 | case INT_RESULT: | |
| 5979 |
1/2✓ Branch 0 taken 1000 times.
✗ Branch 1 not taken.
|
1000 | (void)args[1]->val_int(); |
| 5980 | 1000 | break; | |
| 5981 | 100 | case STRING_RESULT: | |
| 5982 |
1/2✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
|
100 | (void)args[1]->val_str(&tmp); |
| 5983 | 100 | break; | |
| 5984 | 300 | case DECIMAL_RESULT: | |
| 5985 |
1/2✓ Branch 0 taken 300 times.
✗ Branch 1 not taken.
|
300 | (void)args[1]->val_decimal(&tmp_decimal); |
| 5986 | 300 | break; | |
| 5987 | ✗ | case ROW_RESULT: | |
| 5988 | default: | ||
| 5989 | // This case should never be chosen | ||
| 5990 | ✗ | assert(0); | |
| 5991 | return 0; | ||
| 5992 | } | ||
| 5993 | } | ||
| 5994 | 29 | return 0; | |
| 5995 | 32 | } | |
| 5996 | |||
| 5997 | 19 | void Item_func_benchmark::print(const THD *thd, String *str, | |
| 5998 | enum_query_type query_type) const { | ||
| 5999 | 19 | str->append(STRING_WITH_LEN("benchmark(")); | |
| 6000 | 19 | args[0]->print(thd, str, query_type); | |
| 6001 | 19 | str->append(','); | |
| 6002 | 19 | args[1]->print(thd, str, query_type); | |
| 6003 | 19 | str->append(')'); | |
| 6004 | 19 | } | |
| 6005 | |||
| 6006 | /** | ||
| 6007 | Lock which is used to implement interruptible wait for SLEEP() function. | ||
| 6008 | */ | ||
| 6009 | |||
| 6010 | mysql_mutex_t LOCK_item_func_sleep; | ||
| 6011 | |||
| 6012 | #ifdef HAVE_PSI_INTERFACE | ||
| 6013 | static PSI_mutex_key key_LOCK_item_func_sleep; | ||
| 6014 | |||
| 6015 | static PSI_mutex_info item_func_sleep_mutexes[] = { | ||
| 6016 | {&key_LOCK_item_func_sleep, "LOCK_item_func_sleep", PSI_FLAG_SINGLETON, 0, | ||
| 6017 | PSI_DOCUMENT_ME}}; | ||
| 6018 | |||
| 6019 | 9786 | static void init_item_func_sleep_psi_keys() { | |
| 6020 | int count; | ||
| 6021 | |||
| 6022 | 9786 | count = static_cast<int>(array_elements(item_func_sleep_mutexes)); | |
| 6023 | 9786 | mysql_mutex_register("sql", item_func_sleep_mutexes, count); | |
| 6024 | 9786 | } | |
| 6025 | #endif | ||
| 6026 | |||
| 6027 | static bool item_func_sleep_inited = false; | ||
| 6028 | |||
| 6029 | 9786 | void item_func_sleep_init() { | |
| 6030 | #ifdef HAVE_PSI_INTERFACE | ||
| 6031 | 9786 | init_item_func_sleep_psi_keys(); | |
| 6032 | #endif | ||
| 6033 | |||
| 6034 | 9786 | mysql_mutex_init(key_LOCK_item_func_sleep, &LOCK_item_func_sleep, | |
| 6035 | MY_MUTEX_INIT_SLOW); | ||
| 6036 | 9786 | item_func_sleep_inited = true; | |
| 6037 | 9786 | } | |
| 6038 | |||
| 6039 | 8468 | void item_func_sleep_free() { | |
| 6040 |
2/2✓ Branch 0 taken 8430 times.
✓ Branch 1 taken 38 times.
|
8468 | if (item_func_sleep_inited) { |
| 6041 | 8430 | item_func_sleep_inited = false; | |
| 6042 | 8430 | mysql_mutex_destroy(&LOCK_item_func_sleep); | |
| 6043 | } | ||
| 6044 | 8468 | } | |
| 6045 | |||
| 6046 | 7721 | bool Item_func_sleep::itemize(Parse_context *pc, Item **res) { | |
| 6047 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7722 times.
|
7721 | if (skip_itemize(res)) return false; |
| 6048 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7723 times.
|
7722 | if (super::itemize(pc, res)) return true; |
| 6049 | 7723 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 6050 | 7723 | pc->thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT); | |
| 6051 | 7723 | return false; | |
| 6052 | } | ||
| 6053 | |||
| 6054 | /** This function is just used to create tests with time gaps. */ | ||
| 6055 | |||
| 6056 | 10696 | longlong Item_func_sleep::val_int() { | |
| 6057 |
1/2✓ Branch 0 taken 10697 times.
✗ Branch 1 not taken.
|
10696 | THD *thd = current_thd; |
| 6058 | 10697 | Interruptible_wait timed_cond(thd); | |
| 6059 | mysql_cond_t cond; | ||
| 6060 | double timeout; | ||
| 6061 | int error; | ||
| 6062 | |||
| 6063 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10696 times.
|
10696 | assert(fixed == 1); |
| 6064 | |||
| 6065 |
1/2✓ Branch 0 taken 10697 times.
✗ Branch 1 not taken.
|
10696 | timeout = args[0]->val_real(); |
| 6066 | |||
| 6067 | /* | ||
| 6068 | Report error or warning depending on the value of SQL_MODE. | ||
| 6069 | If SQL is STRICT then report error, else report warning and continue | ||
| 6070 | execution. | ||
| 6071 | */ | ||
| 6072 | |||
| 6073 |
3/4✓ Branch 0 taken 10695 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10695 times.
|
10697 | if (args[0]->null_value || timeout < 0) { |
| 6074 |
5/6✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1 times.
|
2 | if (!thd->lex->is_ignore() && thd->is_strict_mode()) { |
| 6075 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_error(ER_WRONG_ARGUMENTS, MYF(0), "sleep."); |
| 6076 | 1 | return 0; | |
| 6077 | } else | ||
| 6078 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | push_warning_printf(thd, Sql_condition::SL_WARNING, ER_WRONG_ARGUMENTS, |
| 6079 | ER_THD(thd, ER_WRONG_ARGUMENTS), "sleep."); | ||
| 6080 | } | ||
| 6081 | /* | ||
| 6082 | On 64-bit OSX mysql_cond_timedwait() waits forever | ||
| 6083 | if passed abstime time has already been exceeded by | ||
| 6084 | the system time. | ||
| 6085 | When given a very short timeout (< 10 mcs) just return | ||
| 6086 | immediately. | ||
| 6087 | We assume that the lines between this test and the call | ||
| 6088 | to mysql_cond_timedwait() will be executed in less than 0.00001 sec. | ||
| 6089 | */ | ||
| 6090 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 10683 times.
|
10696 | if (timeout < 0.00001) return 0; |
| 6091 | |||
| 6092 |
1/2✓ Branch 0 taken 10683 times.
✗ Branch 1 not taken.
|
10683 | timed_cond.set_timeout((ulonglong)(timeout * 1000000000.0)); |
| 6093 | |||
| 6094 |
1/2✓ Branch 0 taken 10683 times.
✗ Branch 1 not taken.
|
10683 | mysql_cond_init(key_item_func_sleep_cond, &cond); |
| 6095 |
1/2✓ Branch 0 taken 10683 times.
✗ Branch 1 not taken.
|
10683 | mysql_mutex_lock(&LOCK_item_func_sleep); |
| 6096 | |||
| 6097 |
1/2✓ Branch 0 taken 10683 times.
✗ Branch 1 not taken.
|
10683 | thd->ENTER_COND(&cond, &LOCK_item_func_sleep, &stage_user_sleep, nullptr); |
| 6098 | |||
| 6099 |
3/6✓ Branch 0 taken 10683 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10683 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10683 times.
✗ Branch 5 not taken.
|
10683 | DEBUG_SYNC(current_thd, "func_sleep_before_sleep"); |
| 6100 | |||
| 6101 | 10683 | error = 0; | |
| 6102 |
1/2✓ Branch 0 taken 10683 times.
✗ Branch 1 not taken.
|
10683 | thd_wait_begin(thd, THD_WAIT_SLEEP); |
| 6103 |
2/2✓ Branch 0 taken 10683 times.
✓ Branch 1 taken 32 times.
|
10715 | while (!thd->killed) { |
| 6104 |
1/2✓ Branch 0 taken 10654 times.
✗ Branch 1 not taken.
|
10683 | error = timed_cond.wait(&cond, &LOCK_item_func_sleep); |
| 6105 |
2/2✓ Branch 0 taken 10622 times.
✓ Branch 1 taken 32 times.
|
10654 | if (is_timeout(error)) break; |
| 6106 | 32 | error = 0; | |
| 6107 | } | ||
| 6108 |
1/2✓ Branch 0 taken 10654 times.
✗ Branch 1 not taken.
|
10654 | thd_wait_end(thd); |
| 6109 |
1/2✓ Branch 0 taken 10654 times.
✗ Branch 1 not taken.
|
10654 | mysql_mutex_unlock(&LOCK_item_func_sleep); |
| 6110 |
1/2✓ Branch 0 taken 10654 times.
✗ Branch 1 not taken.
|
10654 | thd->EXIT_COND(nullptr); |
| 6111 | |||
| 6112 |
1/2✓ Branch 0 taken 10654 times.
✗ Branch 1 not taken.
|
10654 | mysql_cond_destroy(&cond); |
| 6113 | |||
| 6114 | 10654 | return (error == 0); // Return 1 killed | |
| 6115 | } | ||
| 6116 | |||
| 6117 | /** | ||
| 6118 | Get variable with given name; conditionally create it if non-existing | ||
| 6119 | |||
| 6120 | @param thd thread context | ||
| 6121 | @param name name of user variable | ||
| 6122 | @param cs character set; | ||
| 6123 | = NULL: Do not create variable if non-existing. | ||
| 6124 | != NULL: Create variable with this character set. | ||
| 6125 | |||
| 6126 | @returns pointer to variable entry. | ||
| 6127 | = NULL: variable does not exist (if cs == NULL), or | ||
| 6128 | could not create variable (if cs != NULL) | ||
| 6129 | */ | ||
| 6130 | 3440377 | static user_var_entry *get_variable(THD *thd, const Name_string &name, | |
| 6131 | const CHARSET_INFO *cs) { | ||
| 6132 |
1/2✓ Branch 0 taken 3440428 times.
✗ Branch 1 not taken.
|
3440377 | const std::string key(name.ptr(), name.length()); |
| 6133 | |||
| 6134 | /* Protects thd->user_vars. */ | ||
| 6135 | mysql_mutex_assert_owner(&thd->LOCK_thd_data); | ||
| 6136 | |||
| 6137 |
1/2✓ Branch 0 taken 3440448 times.
✗ Branch 1 not taken.
|
3440437 | user_var_entry *entry = find_or_nullptr(thd->user_vars, key); |
| 6138 |
4/4✓ Branch 0 taken 161838 times.
✓ Branch 1 taken 3278610 times.
✓ Branch 2 taken 145303 times.
✓ Branch 3 taken 16535 times.
|
3440448 | if (entry == nullptr && cs != nullptr) { |
| 6139 |
1/2✓ Branch 0 taken 145303 times.
✗ Branch 1 not taken.
|
145303 | entry = user_var_entry::create(thd, name, cs); |
| 6140 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 145300 times.
|
145303 | if (entry == nullptr) return nullptr; |
| 6141 |
1/2✓ Branch 0 taken 145300 times.
✗ Branch 1 not taken.
|
145300 | thd->user_vars.emplace( |
| 6142 | 290600 | key, unique_ptr_with_deleter<user_var_entry>(entry, &free_user_var)); | |
| 6143 | } | ||
| 6144 | 3440445 | return entry; | |
| 6145 | 3440448 | } | |
| 6146 | |||
| 6147 | 850642 | void Item_func_set_user_var::cleanup() { | |
| 6148 | 850642 | Item_func::cleanup(); | |
| 6149 | /* | ||
| 6150 | Ensure that a valid user variable object is rebound on next | ||
| 6151 | execution. This is important if the user variable is referenced by a | ||
| 6152 | trigger: the trigger references an Item_func_set_user_var, and may be | ||
| 6153 | used by another THD in the future (the trigger is cached in a TABLE). When | ||
| 6154 | that later happens, the other THD will use the same Item_func_set_user_var | ||
| 6155 | but shouldn't try to access the previous THD's entry. So we clear it here, | ||
| 6156 | and set it again later in Item_func_set_user_var::update(). | ||
| 6157 | */ | ||
| 6158 | 850673 | entry = nullptr; | |
| 6159 | 850673 | } | |
| 6160 | |||
| 6161 | 1383863 | bool Item_func_set_user_var::set_entry(THD *thd, bool create_if_not_exists) { | |
| 6162 |
2/2✓ Branch 0 taken 1380762 times.
✓ Branch 1 taken 3101 times.
|
1383863 | if (entry == nullptr) { |
| 6163 | const CHARSET_INFO *cs = | ||
| 6164 | create_if_not_exists | ||
| 6165 |
2/2✓ Branch 0 taken 1375333 times.
✓ Branch 1 taken 5429 times.
|
2756111 | ? (args[0]->collation.derivation == DERIVATION_NUMERIC |
| 6166 |
2/2✓ Branch 0 taken 872666 times.
✓ Branch 1 taken 502667 times.
|
1375333 | ? default_charset() |
| 6167 | 502667 | : args[0]->collation.collation) | |
| 6168 | 1380778 | : nullptr; | |
| 6169 | |||
| 6170 | /* Protects thd->user_vars. */ | ||
| 6171 | 1380778 | mysql_mutex_lock(&thd->LOCK_thd_data); | |
| 6172 | 1380757 | entry = get_variable(thd, name, cs); | |
| 6173 | 1380785 | mysql_mutex_unlock(&thd->LOCK_thd_data); | |
| 6174 | |||
| 6175 |
2/2✓ Branch 0 taken 451 times.
✓ Branch 1 taken 1380358 times.
|
1380809 | if (entry == nullptr) return true; |
| 6176 | } | ||
| 6177 | |||
| 6178 | // Ensure this user variable is owned by the current session | ||
| 6179 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1383413 times.
|
1383459 | assert(entry->owner_session() == thd); |
| 6180 | |||
| 6181 | 1383413 | return false; | |
| 6182 | } | ||
| 6183 | |||
| 6184 | /* | ||
| 6185 | When a user variable is updated (in a SET command or a query like | ||
| 6186 | SELECT @a:= ). | ||
| 6187 | */ | ||
| 6188 | |||
| 6189 | 531727 | bool Item_func_set_user_var::fix_fields(THD *thd, Item **ref) { | |
| 6190 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 531727 times.
|
531727 | assert(!fixed); |
| 6191 | |||
| 6192 |
2/2✓ Branch 0 taken 224 times.
✓ Branch 1 taken 531507 times.
|
531727 | if (Item_func::fix_fields(thd, ref)) return true; |
| 6193 | |||
| 6194 | // This is probably only to get an early validity check on user variable name | ||
| 6195 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 531503 times.
|
531507 | if (set_entry(thd, true)) return true; |
| 6196 | 531503 | entry = nullptr; | |
| 6197 | |||
| 6198 | 531503 | null_item = (args[0]->type() == NULL_ITEM); | |
| 6199 | |||
| 6200 | 531503 | return false; | |
| 6201 | } | ||
| 6202 | |||
| 6203 | 531504 | bool Item_func_set_user_var::resolve_type(THD *thd) { | |
| 6204 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 531507 times.
|
531504 | if (Item_var_func::resolve_type(thd)) return true; |
| 6205 | 531507 | set_nullable(args[0]->is_nullable()); | |
| 6206 | 531507 | collation.set(DERIVATION_IMPLICIT); | |
| 6207 | /* | ||
| 6208 | this sets the character set of the item immediately; rules for the | ||
| 6209 | character set of the variable ("entry" object) are different: if "entry" | ||
| 6210 | did not exist previously, set_entry () has created it and has set its | ||
| 6211 | character set; but if it existed previously, it keeps its previous | ||
| 6212 | character set, which may change only when we are sure that the assignment | ||
| 6213 | is to be executed, i.e. in user_var_entry::store (). | ||
| 6214 | */ | ||
| 6215 |
2/2✓ Branch 0 taken 322646 times.
✓ Branch 1 taken 208861 times.
|
531507 | if (args[0]->collation.derivation == DERIVATION_NUMERIC) |
| 6216 | 322646 | collation.collation = default_charset(); | |
| 6217 | else | ||
| 6218 | 208861 | collation.collation = args[0]->collation.collation; | |
| 6219 | |||
| 6220 | 531507 | enum_field_types type = Item::type_for_variable(args[0]->data_type()); | |
| 6221 |
4/5✓ Branch 0 taken 304010 times.
✓ Branch 1 taken 3322 times.
✓ Branch 2 taken 15138 times.
✓ Branch 3 taken 209035 times.
✗ Branch 4 not taken.
|
531505 | switch (type) { |
| 6222 | 304010 | case MYSQL_TYPE_LONGLONG: | |
| 6223 | 304010 | set_data_type_longlong(); | |
| 6224 | 304009 | unsigned_flag = args[0]->unsigned_flag; | |
| 6225 | 304009 | max_length = | |
| 6226 | 304009 | args[0]->max_length; // Preserves "length" of integer constants | |
| 6227 | 304009 | break; | |
| 6228 | 3322 | case MYSQL_TYPE_NEWDECIMAL: | |
| 6229 | 3322 | set_data_type_decimal(args[0]->decimal_precision(), args[0]->decimals); | |
| 6230 | 3322 | break; | |
| 6231 | 15138 | case MYSQL_TYPE_DOUBLE: | |
| 6232 | 15138 | set_data_type_double(); | |
| 6233 | 15138 | break; | |
| 6234 | 209035 | case MYSQL_TYPE_VARCHAR: | |
| 6235 | 209035 | set_data_type_string(args[0]->max_char_length()); | |
| 6236 | 209035 | break; | |
| 6237 | ✗ | case MYSQL_TYPE_NULL: | |
| 6238 | default: | ||
| 6239 | ✗ | assert(false); | |
| 6240 | set_data_type(MYSQL_TYPE_NULL); | ||
| 6241 | break; | ||
| 6242 | } | ||
| 6243 | |||
| 6244 | 531504 | cached_result_type = Item::type_to_result(data_type()); | |
| 6245 | |||
| 6246 | 531505 | return false; | |
| 6247 | } | ||
| 6248 | |||
| 6249 | // static | ||
| 6250 | 145303 | user_var_entry *user_var_entry::create(THD *thd, const Name_string &name, | |
| 6251 | const CHARSET_INFO *cs) { | ||
| 6252 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 145300 times.
|
145303 | if (check_column_name(name.ptr())) { |
| 6253 | 3 | my_error(ER_ILLEGAL_USER_VAR, MYF(0), name.ptr()); | |
| 6254 | 3 | return nullptr; | |
| 6255 | } | ||
| 6256 | |||
| 6257 | user_var_entry *entry; | ||
| 6258 | size_t size = | ||
| 6259 | 145300 | ALIGN_SIZE(sizeof(user_var_entry)) + (name.length() + 1) + extra_size; | |
| 6260 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 145300 times.
|
145300 | if (!(entry = (user_var_entry *)my_malloc(key_memory_user_var_entry, size, |
| 6261 | MYF(MY_WME | ME_FATALERROR)))) | ||
| 6262 | ✗ | return nullptr; | |
| 6263 | 145300 | entry->init(thd, name, cs); | |
| 6264 | 145300 | return entry; | |
| 6265 | } | ||
| 6266 | |||
| 6267 | 4068343 | bool user_var_entry::mem_realloc(size_t length) { | |
| 6268 |
2/2✓ Branch 0 taken 3741656 times.
✓ Branch 1 taken 326687 times.
|
4068343 | if (length <= extra_size) { |
| 6269 | /* Enough space to store value in value struct */ | ||
| 6270 | 3741656 | free_value(); | |
| 6271 | 3741690 | m_ptr = internal_buffer_ptr(); | |
| 6272 | } else { | ||
| 6273 | /* Allocate an external buffer */ | ||
| 6274 |
2/2✓ Branch 0 taken 322350 times.
✓ Branch 1 taken 4337 times.
|
326687 | if (m_length != length) { |
| 6275 |
2/2✓ Branch 0 taken 10643 times.
✓ Branch 1 taken 311711 times.
|
322350 | if (m_ptr == internal_buffer_ptr()) m_ptr = nullptr; |
| 6276 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 322354 times.
|
322354 | if (!(m_ptr = (char *)my_realloc( |
| 6277 | 322354 | key_memory_user_var_entry_value, m_ptr, length, | |
| 6278 | MYF(MY_ALLOW_ZERO_PTR | MY_WME | ME_FATALERROR)))) | ||
| 6279 | ✗ | return true; | |
| 6280 | } | ||
| 6281 | } | ||
| 6282 | 4068400 | return false; | |
| 6283 | } | ||
| 6284 | |||
| 6285 | 145300 | void user_var_entry::init(THD *thd, const Simple_cstring &name, | |
| 6286 | const CHARSET_INFO *cs) { | ||
| 6287 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 145300 times.
|
145300 | assert(thd != nullptr); |
| 6288 | 145300 | m_owner = thd; | |
| 6289 | 145300 | copy_name(name); | |
| 6290 | 145300 | reset_value(); | |
| 6291 | 145300 | m_used_query_id = 0; | |
| 6292 | 145300 | collation.set(cs, DERIVATION_IMPLICIT, 0); | |
| 6293 | 145300 | unsigned_flag = false; | |
| 6294 | 145300 | m_type = STRING_RESULT; | |
| 6295 | 145300 | } | |
| 6296 | |||
| 6297 | 4068347 | bool user_var_entry::store(const void *from, size_t length, Item_result type) { | |
| 6298 | 4068347 | assert_locked(); | |
| 6299 | |||
| 6300 | // Store strings with end \0 | ||
| 6301 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4068400 times.
|
4068376 | if (mem_realloc(length + (type == STRING_RESULT))) return true; |
| 6302 |
2/2✓ Branch 0 taken 372782 times.
✓ Branch 1 taken 3695618 times.
|
4068400 | if (type == STRING_RESULT) m_ptr[length] = 0; // Store end \0 |
| 6303 | |||
| 6304 | // Avoid memcpy of a my_decimal object, use copy CTOR instead. | ||
| 6305 |
2/2✓ Branch 0 taken 2663 times.
✓ Branch 1 taken 4065737 times.
|
4068400 | if (type == DECIMAL_RESULT) { |
| 6306 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2663 times.
|
2663 | assert(length == sizeof(my_decimal)); |
| 6307 | 2663 | const my_decimal *dec = static_cast<const my_decimal *>(from); | |
| 6308 | 2663 | dec->sanity_check(); | |
| 6309 |
1/2✓ Branch 0 taken 2663 times.
✗ Branch 1 not taken.
|
2663 | new (m_ptr) my_decimal(*dec); |
| 6310 | } else | ||
| 6311 | 4065737 | memcpy(m_ptr, from, length); | |
| 6312 | |||
| 6313 | 4068400 | m_length = length; | |
| 6314 | 4068400 | m_type = type; | |
| 6315 | |||
| 6316 | 4068400 | set_used_query_id(current_thd->query_id); | |
| 6317 | |||
| 6318 | 4068378 | return false; | |
| 6319 | } | ||
| 6320 | |||
| 6321 | 8285064 | void user_var_entry::assert_locked() const { | |
| 6322 | mysql_mutex_assert_owner(&m_owner->LOCK_thd_data); | ||
| 6323 | 8285064 | } | |
| 6324 | |||
| 6325 | 4068351 | bool user_var_entry::store(const void *ptr, size_t length, Item_result type, | |
| 6326 | const CHARSET_INFO *cs, Derivation dv, | ||
| 6327 | bool unsigned_arg) { | ||
| 6328 | 4068351 | assert_locked(); | |
| 6329 | |||
| 6330 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4068381 times.
|
4068402 | if (store(ptr, length, type)) return true; |
| 6331 | 4068381 | collation.set(cs, dv); | |
| 6332 | 4068357 | unsigned_flag = unsigned_arg; | |
| 6333 | 4068357 | return false; | |
| 6334 | } | ||
| 6335 | |||
| 6336 | 4071722 | void user_var_entry::lock() { | |
| 6337 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4071722 times.
|
4071722 | assert(m_owner != nullptr); |
| 6338 | 4071722 | mysql_mutex_lock(&m_owner->LOCK_thd_data); | |
| 6339 | 4071740 | } | |
| 6340 | |||
| 6341 | 4071716 | void user_var_entry::unlock() { | |
| 6342 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4071716 times.
|
4071716 | assert(m_owner != nullptr); |
| 6343 | 4071716 | mysql_mutex_unlock(&m_owner->LOCK_thd_data); | |
| 6344 | 4071783 | } | |
| 6345 | |||
| 6346 | 4070859 | bool Item_func_set_user_var::update_hash(const void *ptr, uint length, | |
| 6347 | Item_result res_type, | ||
| 6348 | const CHARSET_INFO *cs, Derivation dv, | ||
| 6349 | bool unsigned_arg) { | ||
| 6350 | 4070859 | entry->lock(); | |
| 6351 | |||
| 6352 | // args[0]->null_value could be outdated | ||
| 6353 |
2/2✓ Branch 0 taken 23025 times.
✓ Branch 1 taken 4047813 times.
|
4070877 | if (args[0]->type() == Item::FIELD_ITEM) |
| 6354 | 23025 | null_value = ((Item_field *)args[0])->field->is_null(); | |
| 6355 | else | ||
| 6356 | 4047813 | null_value = args[0]->null_value; | |
| 6357 | |||
| 6358 |
2/2✓ Branch 0 taken 2516 times.
✓ Branch 1 taken 4068322 times.
|
4070838 | if (ptr == nullptr) { |
| 6359 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2516 times.
|
2516 | assert(length == 0); |
| 6360 | 2516 | null_value = true; | |
| 6361 | } | ||
| 6362 | |||
| 6363 | /* | ||
| 6364 | If we set a variable explicitly to NULL then keep the old | ||
| 6365 | result type of the variable | ||
| 6366 | */ | ||
| 6367 |
4/4✓ Branch 0 taken 3326 times.
✓ Branch 1 taken 4067512 times.
✓ Branch 2 taken 857 times.
✓ Branch 3 taken 2469 times.
|
4070838 | if (null_value && null_item) res_type = entry->type(); |
| 6368 | |||
| 6369 |
2/2✓ Branch 0 taken 3325 times.
✓ Branch 1 taken 4067514 times.
|
4070839 | if (null_value) |
| 6370 | 3325 | entry->set_null_value(res_type); | |
| 6371 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4067525 times.
|
4067514 | else if (entry->store(ptr, length, res_type, cs, dv, unsigned_arg)) { |
| 6372 | ✗ | entry->unlock(); | |
| 6373 | ✗ | null_value = true; | |
| 6374 | ✗ | return true; | |
| 6375 | } | ||
| 6376 | 4070851 | entry->unlock(); | |
| 6377 | 4070919 | return false; | |
| 6378 | } | ||
| 6379 | |||
| 6380 | /** Get the value of a variable as a double. */ | ||
| 6381 | |||
| 6382 | 581428 | double user_var_entry::val_real(bool *null_value) const { | |
| 6383 |
2/2✓ Branch 0 taken 206 times.
✓ Branch 1 taken 581222 times.
|
581428 | if ((*null_value = (m_ptr == nullptr))) return 0.0; |
| 6384 | |||
| 6385 |
4/6✓ Branch 0 taken 85699 times.
✓ Branch 1 taken 491738 times.
✓ Branch 2 taken 1164 times.
✓ Branch 3 taken 2621 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
581222 | switch (m_type) { |
| 6386 | 85699 | case REAL_RESULT: | |
| 6387 | 85699 | return *reinterpret_cast<double *>(m_ptr); | |
| 6388 | 491738 | case INT_RESULT: | |
| 6389 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 491730 times.
|
491738 | if (unsigned_flag) |
| 6390 | 8 | return static_cast<double>(*reinterpret_cast<ulonglong *>(m_ptr)); | |
| 6391 | else | ||
| 6392 | 491730 | return static_cast<double>(*reinterpret_cast<longlong *>(m_ptr)); | |
| 6393 | 1164 | case DECIMAL_RESULT: { | |
| 6394 | double result; | ||
| 6395 |
1/2✓ Branch 0 taken 1164 times.
✗ Branch 1 not taken.
|
1164 | my_decimal2double(E_DEC_FATAL_ERROR, (my_decimal *)m_ptr, &result); |
| 6396 | 1164 | return result; | |
| 6397 | } | ||
| 6398 | 2621 | case STRING_RESULT: | |
| 6399 | 5242 | return double_from_string_with_check(collation.collation, m_ptr, | |
| 6400 | 2621 | m_ptr + m_length); | |
| 6401 | ✗ | case ROW_RESULT: | |
| 6402 | case INVALID_RESULT: | ||
| 6403 | ✗ | assert(false); // Impossible | |
| 6404 | break; | ||
| 6405 | } | ||
| 6406 | ✗ | return 0.0; // Impossible | |
| 6407 | } | ||
| 6408 | |||
| 6409 | /** Get the value of a variable as an integer. */ | ||
| 6410 | |||
| 6411 | 11418788 | longlong user_var_entry::val_int(bool *null_value) const { | |
| 6412 |
2/2✓ Branch 0 taken 1073 times.
✓ Branch 1 taken 11417715 times.
|
11418788 | if ((*null_value = (m_ptr == nullptr))) return 0LL; |
| 6413 | |||
| 6414 |
4/6✓ Branch 0 taken 112076 times.
✓ Branch 1 taken 11301484 times.
✓ Branch 2 taken 4089 times.
✓ Branch 3 taken 70 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
11417715 | switch (m_type) { |
| 6415 | 112076 | case REAL_RESULT: { | |
| 6416 | // TODO(tdidriks): Consider reporting a possible overflow warning. | ||
| 6417 | 112076 | double var_val = *(reinterpret_cast<double *>(m_ptr)); | |
| 6418 | longlong res; | ||
| 6419 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 112076 times.
|
112076 | if (var_val <= LLONG_MIN) { |
| 6420 | ✗ | res = LLONG_MIN; | |
| 6421 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 112076 times.
|
112076 | } else if (var_val >= LLONG_MAX_DOUBLE) { |
| 6422 | ✗ | res = LLONG_MAX; | |
| 6423 | } else | ||
| 6424 | 112076 | res = var_val; | |
| 6425 | |||
| 6426 | 112076 | return res; | |
| 6427 | } | ||
| 6428 | 11301484 | case INT_RESULT: | |
| 6429 | 11301484 | return *(longlong *)m_ptr; | |
| 6430 | 4089 | case DECIMAL_RESULT: { | |
| 6431 | longlong result; | ||
| 6432 |
1/2✓ Branch 0 taken 4089 times.
✗ Branch 1 not taken.
|
4089 | my_decimal2int(E_DEC_FATAL_ERROR, (my_decimal *)m_ptr, false, &result); |
| 6433 | 4089 | return result; | |
| 6434 | } | ||
| 6435 | 70 | case STRING_RESULT: { | |
| 6436 | int error; | ||
| 6437 |
1/2✓ Branch 0 taken 70 times.
✗ Branch 1 not taken.
|
70 | return my_strtoll10(m_ptr, nullptr, |
| 6438 | 70 | &error); // String is null terminated | |
| 6439 | } | ||
| 6440 | ✗ | case ROW_RESULT: | |
| 6441 | case INVALID_RESULT: | ||
| 6442 | ✗ | assert(false); // Impossible | |
| 6443 | break; | ||
| 6444 | } | ||
| 6445 | ✗ | return 0LL; // Impossible | |
| 6446 | } | ||
| 6447 | |||
| 6448 | /** Get the value of a variable as a string. */ | ||
| 6449 | |||
| 6450 | 1953354 | String *user_var_entry::val_str(bool *null_value, String *str, | |
| 6451 | uint decimals) const { | ||
| 6452 |
2/2✓ Branch 0 taken 4078 times.
✓ Branch 1 taken 1949276 times.
|
1953354 | if ((*null_value = (m_ptr == nullptr))) return (String *)nullptr; |
| 6453 | |||
| 6454 |
4/6✓ Branch 0 taken 63 times.
✓ Branch 1 taken 81155 times.
✓ Branch 2 taken 267 times.
✓ Branch 3 taken 1867797 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
1949276 | switch (m_type) { |
| 6455 | 63 | case REAL_RESULT: | |
| 6456 | 63 | str->set_real(*(double *)m_ptr, decimals, collation.collation); | |
| 6457 | 63 | break; | |
| 6458 | 81155 | case INT_RESULT: | |
| 6459 |
2/2✓ Branch 0 taken 80930 times.
✓ Branch 1 taken 225 times.
|
81155 | if (!unsigned_flag) |
| 6460 | 80930 | str->set(*(longlong *)m_ptr, collation.collation); | |
| 6461 | else | ||
| 6462 | 225 | str->set(*(ulonglong *)m_ptr, collation.collation); | |
| 6463 | 81154 | break; | |
| 6464 | 267 | case DECIMAL_RESULT: | |
| 6465 | 267 | str_set_decimal(E_DEC_FATAL_ERROR, pointer_cast<my_decimal *>(m_ptr), str, | |
| 6466 | 267 | collation.collation, decimals); | |
| 6467 | 271 | break; | |
| 6468 | 1867797 | case STRING_RESULT: | |
| 6469 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1867801 times.
|
1867797 | if (str->copy(m_ptr, m_length, collation.collation)) |
| 6470 | ✗ | str = nullptr; // EOM error | |
| 6471 | 1867801 | break; | |
| 6472 | ✗ | case ROW_RESULT: | |
| 6473 | case INVALID_RESULT: | ||
| 6474 | ✗ | assert(false); // Impossible | |
| 6475 | break; | ||
| 6476 | } | ||
| 6477 | 1949283 | return (str); | |
| 6478 | } | ||
| 6479 | |||
| 6480 | /** Get the value of a variable as a decimal. */ | ||
| 6481 | |||
| 6482 | 181847 | my_decimal *user_var_entry::val_decimal(bool *null_value, | |
| 6483 | my_decimal *val) const { | ||
| 6484 |
2/2✓ Branch 0 taken 141 times.
✓ Branch 1 taken 181706 times.
|
181847 | if ((*null_value = (m_ptr == nullptr))) return nullptr; |
| 6485 | |||
| 6486 |
4/6✓ Branch 0 taken 1 times.
✓ Branch 1 taken 180041 times.
✓ Branch 2 taken 1659 times.
✓ Branch 3 taken 5 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
181706 | switch (m_type) { |
| 6487 | 1 | case REAL_RESULT: | |
| 6488 | 1 | double2my_decimal(E_DEC_FATAL_ERROR, *(double *)m_ptr, val); | |
| 6489 | 1 | break; | |
| 6490 | 180041 | case INT_RESULT: | |
| 6491 | 180041 | int2my_decimal(E_DEC_FATAL_ERROR, *pointer_cast<longlong *>(m_ptr), | |
| 6492 | 180041 | unsigned_flag, val); | |
| 6493 | 180041 | break; | |
| 6494 | 1659 | case DECIMAL_RESULT: | |
| 6495 | 1659 | my_decimal2decimal(reinterpret_cast<my_decimal *>(m_ptr), val); | |
| 6496 | 1659 | break; | |
| 6497 | 5 | case STRING_RESULT: | |
| 6498 | 5 | str2my_decimal(E_DEC_FATAL_ERROR, m_ptr, m_length, collation.collation, | |
| 6499 | val); | ||
| 6500 | 5 | break; | |
| 6501 | ✗ | case ROW_RESULT: | |
| 6502 | case INVALID_RESULT: | ||
| 6503 | ✗ | assert(false); // Impossible | |
| 6504 | break; | ||
| 6505 | } | ||
| 6506 | 181706 | return (val); | |
| 6507 | } | ||
| 6508 | |||
| 6509 | /** | ||
| 6510 | This functions is invoked on SET \@variable or | ||
| 6511 | \@variable:= expression. | ||
| 6512 | |||
| 6513 | Evaluate (and check expression), store results. | ||
| 6514 | |||
| 6515 | @note | ||
| 6516 | For now it always return OK. All problem with value evaluating | ||
| 6517 | will be caught by thd->is_error() check in sql_set_variables(). | ||
| 6518 | |||
| 6519 | @retval | ||
| 6520 | false OK. | ||
| 6521 | */ | ||
| 6522 | |||
| 6523 | 3956695 | bool Item_func_set_user_var::check(bool use_result_field) { | |
| 6524 |
1/2✓ Branch 0 taken 3956758 times.
✗ Branch 1 not taken.
|
3956695 | DBUG_TRACE; |
| 6525 |
3/4✓ Branch 0 taken 29 times.
✓ Branch 1 taken 3956729 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 29 times.
|
3956758 | if (use_result_field && !result_field) use_result_field = false; |
| 6526 | |||
| 6527 |
5/5✓ Branch 0 taken 93351 times.
✓ Branch 1 taken 3498508 times.
✓ Branch 2 taken 362426 times.
✓ Branch 3 taken 2451 times.
✓ Branch 4 taken 22 times.
|
3956758 | switch (cached_result_type) { |
| 6528 | 93351 | case REAL_RESULT: { | |
| 6529 | 93351 | save_result.vreal = | |
| 6530 |
4/6✓ Branch 0 taken 4 times.
✓ Branch 1 taken 93347 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 93347 times.
✗ Branch 5 not taken.
|
93351 | use_result_field ? result_field->val_real() : args[0]->val_real(); |
| 6531 | 93351 | break; | |
| 6532 | } | ||
| 6533 | 3498508 | case INT_RESULT: { | |
| 6534 | 3498489 | save_result.vint = | |
| 6535 |
4/6✓ Branch 0 taken 13 times.
✓ Branch 1 taken 3498495 times.
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3498476 times.
✗ Branch 5 not taken.
|
3498508 | use_result_field ? result_field->val_int() : args[0]->val_int(); |
| 6536 |
3/4✓ Branch 0 taken 13 times.
✓ Branch 1 taken 3498476 times.
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
|
3498489 | unsigned_flag = use_result_field ? result_field->is_unsigned() |
| 6537 | 3498476 | : args[0]->unsigned_flag; | |
| 6538 | 3498489 | break; | |
| 6539 | } | ||
| 6540 | 362426 | case STRING_RESULT: { | |
| 6541 |
3/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 362418 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
|
362426 | save_result.vstr = use_result_field ? result_field->val_str(&value) |
| 6542 |
1/2✓ Branch 0 taken 362417 times.
✗ Branch 1 not taken.
|
362418 | : args[0]->val_str(&value); |
| 6543 | 362425 | break; | |
| 6544 | } | ||
| 6545 | 2451 | case DECIMAL_RESULT: { | |
| 6546 | 2451 | save_result.vdec = use_result_field | |
| 6547 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2447 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
2451 | ? result_field->val_decimal(&decimal_buff) |
| 6548 |
1/2✓ Branch 0 taken 2447 times.
✗ Branch 1 not taken.
|
2447 | : args[0]->val_decimal(&decimal_buff); |
| 6549 | 2451 | break; | |
| 6550 | } | ||
| 6551 | 22 | case ROW_RESULT: | |
| 6552 | default: | ||
| 6553 | // This case should never be chosen | ||
| 6554 | 22 | assert(0); | |
| 6555 | break; | ||
| 6556 | } | ||
| 6557 | 3956731 | return false; | |
| 6558 | 3956716 | } | |
| 6559 | |||
| 6560 | /** | ||
| 6561 | @brief Evaluate and store item's result. | ||
| 6562 | This function is invoked on "SELECT ... INTO @var ...". | ||
| 6563 | |||
| 6564 | @param item An item to get value from. | ||
| 6565 | */ | ||
| 6566 | |||
| 6567 | 107288 | void Item_func_set_user_var::save_item_result(Item *item) { | |
| 6568 |
1/2✓ Branch 0 taken 107289 times.
✗ Branch 1 not taken.
|
107288 | DBUG_TRACE; |
| 6569 | |||
| 6570 |
4/5✓ Branch 0 taken 11660 times.
✓ Branch 1 taken 88148 times.
✓ Branch 2 taken 6372 times.
✓ Branch 3 taken 1109 times.
✗ Branch 4 not taken.
|
107289 | switch (cached_result_type) { |
| 6571 | 11660 | case REAL_RESULT: | |
| 6572 |
1/2✓ Branch 0 taken 11659 times.
✗ Branch 1 not taken.
|
11660 | save_result.vreal = item->val_real(); |
| 6573 | 11659 | break; | |
| 6574 | 88148 | case INT_RESULT: | |
| 6575 |
1/2✓ Branch 0 taken 88148 times.
✗ Branch 1 not taken.
|
88148 | save_result.vint = item->val_int(); |
| 6576 | 88148 | unsigned_flag = item->unsigned_flag; | |
| 6577 | 88148 | break; | |
| 6578 | 6372 | case STRING_RESULT: | |
| 6579 |
1/2✓ Branch 0 taken 6372 times.
✗ Branch 1 not taken.
|
6372 | save_result.vstr = item->val_str(&value); |
| 6580 | 6372 | break; | |
| 6581 | 1109 | case DECIMAL_RESULT: | |
| 6582 |
1/2✓ Branch 0 taken 1109 times.
✗ Branch 1 not taken.
|
1109 | save_result.vdec = item->val_decimal(&decimal_buff); |
| 6583 | 1109 | break; | |
| 6584 | ✗ | case ROW_RESULT: | |
| 6585 | default: | ||
| 6586 | // Should never happen | ||
| 6587 | ✗ | assert(0); | |
| 6588 | break; | ||
| 6589 | } | ||
| 6590 | 107288 | } | |
| 6591 | |||
| 6592 | /** | ||
| 6593 | Update user variable from value in save_result | ||
| 6594 | |||
| 6595 | @returns false if success, true when error (EOM) | ||
| 6596 | */ | ||
| 6597 | |||
| 6598 | 4063947 | bool Item_func_set_user_var::update() { | |
| 6599 |
1/2✓ Branch 0 taken 4063998 times.
✗ Branch 1 not taken.
|
4063947 | DBUG_TRACE; |
| 6600 | |||
| 6601 | // Ensure that a user variable object is bound for each execution. | ||
| 6602 |
6/10✓ Branch 0 taken 840047 times.
✓ Branch 1 taken 3223951 times.
✓ Branch 2 taken 840043 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 840017 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 840017 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 4063968 times.
|
4063998 | if (entry == nullptr && set_entry(current_thd, true)) return true; |
| 6603 | |||
| 6604 | 4063968 | bool res = false; | |
| 6605 | |||
| 6606 |
4/5✓ Branch 0 taken 105010 times.
✓ Branch 1 taken 3586642 times.
✓ Branch 2 taken 368765 times.
✓ Branch 3 taken 3560 times.
✗ Branch 4 not taken.
|
4063968 | switch (cached_result_type) { |
| 6607 | 105010 | case REAL_RESULT: { | |
| 6608 |
2/4✓ Branch 0 taken 105010 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 105010 times.
✗ Branch 3 not taken.
|
105010 | res = update_hash(&save_result.vreal, sizeof(save_result.vreal), |
| 6609 | REAL_RESULT, default_charset(), DERIVATION_IMPLICIT, | ||
| 6610 | false); | ||
| 6611 | 105010 | break; | |
| 6612 | } | ||
| 6613 | 3586642 | case INT_RESULT: { | |
| 6614 |
1/2✓ Branch 0 taken 3586673 times.
✗ Branch 1 not taken.
|
3586644 | res = update_hash(&save_result.vint, sizeof(save_result.vint), INT_RESULT, |
| 6615 |
1/2✓ Branch 0 taken 3586644 times.
✗ Branch 1 not taken.
|
3586642 | default_charset(), DERIVATION_IMPLICIT, unsigned_flag); |
| 6616 | 3586673 | break; | |
| 6617 | } | ||
| 6618 | 368765 | case STRING_RESULT: { | |
| 6619 |
2/2✓ Branch 0 taken 1570 times.
✓ Branch 1 taken 367195 times.
|
368765 | if (!save_result.vstr) // Null value |
| 6620 |
1/2✓ Branch 0 taken 1570 times.
✗ Branch 1 not taken.
|
1570 | res = update_hash(nullptr, 0, STRING_RESULT, &my_charset_bin, |
| 6621 | DERIVATION_IMPLICIT, false); | ||
| 6622 | else | ||
| 6623 |
1/2✓ Branch 0 taken 367199 times.
✗ Branch 1 not taken.
|
367194 | res = update_hash(save_result.vstr->ptr(), save_result.vstr->length(), |
| 6624 | 367195 | STRING_RESULT, save_result.vstr->charset(), | |
| 6625 | DERIVATION_IMPLICIT, false); | ||
| 6626 | 368769 | break; | |
| 6627 | } | ||
| 6628 | 3560 | case DECIMAL_RESULT: { | |
| 6629 |
2/2✓ Branch 0 taken 904 times.
✓ Branch 1 taken 2656 times.
|
3560 | if (!save_result.vdec) // Null value |
| 6630 |
1/2✓ Branch 0 taken 904 times.
✗ Branch 1 not taken.
|
904 | res = update_hash(nullptr, 0, DECIMAL_RESULT, &my_charset_bin, |
| 6631 | DERIVATION_IMPLICIT, false); | ||
| 6632 | else | ||
| 6633 |
2/4✓ Branch 0 taken 2656 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2656 times.
✗ Branch 3 not taken.
|
2656 | res = update_hash(save_result.vdec, sizeof(my_decimal), DECIMAL_RESULT, |
| 6634 | default_charset(), DERIVATION_IMPLICIT, false); | ||
| 6635 | 3560 | break; | |
| 6636 | } | ||
| 6637 | ✗ | case ROW_RESULT: | |
| 6638 | default: | ||
| 6639 | // This case should never be chosen | ||
| 6640 | ✗ | assert(0); | |
| 6641 | break; | ||
| 6642 | } | ||
| 6643 | 4064012 | return res; | |
| 6644 | 4064012 | } | |
| 6645 | |||
| 6646 | 175 | double Item_func_set_user_var::val_real() { | |
| 6647 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 175 times.
|
175 | assert(fixed == 1); |
| 6648 | 175 | check(false); | |
| 6649 | 175 | update(); // Store expression | |
| 6650 | 175 | return entry->val_real(&null_value); | |
| 6651 | } | ||
| 6652 | |||
| 6653 | 110375 | longlong Item_func_set_user_var::val_int() { | |
| 6654 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 110375 times.
|
110375 | assert(fixed == 1); |
| 6655 | 110375 | check(false); | |
| 6656 | 110375 | update(); // Store expression | |
| 6657 | 110375 | return entry->val_int(&null_value); | |
| 6658 | } | ||
| 6659 | |||
| 6660 | 62795 | String *Item_func_set_user_var::val_str(String *str) { | |
| 6661 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62795 times.
|
62795 | assert(fixed == 1); |
| 6662 | 62795 | check(false); | |
| 6663 | 62795 | update(); // Store expression | |
| 6664 | 62795 | return entry->val_str(&null_value, str, decimals); | |
| 6665 | } | ||
| 6666 | |||
| 6667 | 90026 | my_decimal *Item_func_set_user_var::val_decimal(my_decimal *val) { | |
| 6668 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 90026 times.
|
90026 | assert(fixed == 1); |
| 6669 | 90026 | check(false); | |
| 6670 | 90026 | update(); // Store expression | |
| 6671 | 90026 | return entry->val_decimal(&null_value, val); | |
| 6672 | } | ||
| 6673 | |||
| 6674 | // just the assignment, for use in "SET @a:=5" type self-prints | ||
| 6675 | 55 | void Item_func_set_user_var::print_assignment( | |
| 6676 | const THD *thd, String *str, enum_query_type query_type) const { | ||
| 6677 | 55 | str->append(STRING_WITH_LEN("@")); | |
| 6678 | 55 | str->append(name); | |
| 6679 | 55 | str->append(STRING_WITH_LEN(":=")); | |
| 6680 | 55 | args[0]->print(thd, str, query_type); | |
| 6681 | 55 | } | |
| 6682 | |||
| 6683 | // parenthesize assignment for use in "EXPLAIN EXTENDED SELECT (@e:=80)+5" | ||
| 6684 | 55 | void Item_func_set_user_var::print(const THD *thd, String *str, | |
| 6685 | enum_query_type query_type) const { | ||
| 6686 | 55 | str->append(STRING_WITH_LEN("(")); | |
| 6687 | 55 | print_assignment(thd, str, query_type); | |
| 6688 | 55 | str->append(STRING_WITH_LEN(")")); | |
| 6689 | 55 | } | |
| 6690 | |||
| 6691 | 11189 | bool Item_func_set_user_var::send(Protocol *protocol, String *str_arg) { | |
| 6692 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 11165 times.
|
11189 | if (result_field) { |
| 6693 | 24 | check(true); | |
| 6694 | 24 | update(); | |
| 6695 | /* | ||
| 6696 | TODO This func have to be changed to avoid sending data as a field. | ||
| 6697 | */ | ||
| 6698 | 24 | return protocol->store_field(result_field); | |
| 6699 | } | ||
| 6700 | 11165 | return Item::send(protocol, str_arg); | |
| 6701 | } | ||
| 6702 | |||
| 6703 | 3180 | void Item_func_set_user_var::make_field(Send_field *tmp_field) { | |
| 6704 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 3171 times.
|
3180 | if (result_field) { |
| 6705 | 9 | result_field->make_send_field(tmp_field); | |
| 6706 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | assert(tmp_field->table_name != nullptr); |
| 6707 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | if (Item::item_name.is_set()) |
| 6708 | 9 | tmp_field->col_name = Item::item_name.ptr(); // Use user supplied name | |
| 6709 | } else | ||
| 6710 | 3171 | Item::make_field(tmp_field); | |
| 6711 | 3180 | } | |
| 6712 | |||
| 6713 | /* | ||
| 6714 | Save the value of a user variable into a field | ||
| 6715 | |||
| 6716 | SYNOPSIS | ||
| 6717 | save_in_field() | ||
| 6718 | field target field to save the value to | ||
| 6719 | no_conversion flag indicating whether conversions are allowed | ||
| 6720 | |||
| 6721 | DESCRIPTION | ||
| 6722 | Save the function value into a field and update the user variable | ||
| 6723 | accordingly. If a result field is defined and the target field doesn't | ||
| 6724 | coincide with it then the value from the result field will be used as | ||
| 6725 | the new value of the user variable. | ||
| 6726 | |||
| 6727 | The reason to have this method rather than simply using the result | ||
| 6728 | field in the val_xxx() methods is that the value from the result field | ||
| 6729 | not always can be used when the result field is defined. | ||
| 6730 | Let's consider the following cases: | ||
| 6731 | 1) when filling a tmp table the result field is defined but the value of it | ||
| 6732 | is undefined because it has to be produced yet. Thus we can't use it. | ||
| 6733 | 2) on execution of an INSERT ... SELECT statement the save_in_field() | ||
| 6734 | function will be called to fill the data in the new record. If the SELECT | ||
| 6735 | part uses a tmp table then the result field is defined and should be | ||
| 6736 | used in order to get the correct result. | ||
| 6737 | |||
| 6738 | The difference between the SET_USER_VAR function and regular functions | ||
| 6739 | like CONCAT is that the Item_func objects for the regular functions are | ||
| 6740 | replaced by Item_field objects after the values of these functions have | ||
| 6741 | been stored in a tmp table. Yet an object of the Item_field class cannot | ||
| 6742 | be used to update a user variable. | ||
| 6743 | Due to this we have to handle the result field in a special way here and | ||
| 6744 | in the Item_func_set_user_var::send() function. | ||
| 6745 | |||
| 6746 | RETURN VALUES | ||
| 6747 | TYPE_OK Ok | ||
| 6748 | Everything else Error | ||
| 6749 | */ | ||
| 6750 | |||
| 6751 | 2964588 | type_conversion_status Item_func_set_user_var::save_in_field( | |
| 6752 | Field *field, bool no_conversions, bool can_use_result_field) { | ||
| 6753 | 2964588 | bool use_result_field = | |
| 6754 |
6/6✓ Branch 0 taken 2964544 times.
✓ Branch 1 taken 44 times.
✓ Branch 2 taken 143677 times.
✓ Branch 3 taken 2820867 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 143672 times.
|
2964588 | (!can_use_result_field ? 0 : (result_field && result_field != field)); |
| 6755 | type_conversion_status error; | ||
| 6756 | |||
| 6757 | /* Update the value of the user variable */ | ||
| 6758 | 2964588 | check(use_result_field); | |
| 6759 | 2964588 | update(); | |
| 6760 | |||
| 6761 |
4/4✓ Branch 0 taken 2886527 times.
✓ Branch 1 taken 78061 times.
✓ Branch 2 taken 78071 times.
✓ Branch 3 taken 2886517 times.
|
5851115 | if (result_type() == STRING_RESULT || |
| 6762 |
4/4✓ Branch 0 taken 40 times.
✓ Branch 1 taken 2886487 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 30 times.
|
2886527 | (result_type() == REAL_RESULT && field->result_type() == STRING_RESULT)) { |
| 6763 | String *result; | ||
| 6764 | 78071 | const CHARSET_INFO *cs = collation.collation; | |
| 6765 | char buff[MAX_FIELD_WIDTH]; // Alloc buffer for small columns | ||
| 6766 | 78071 | str_value.set_quick(buff, sizeof(buff), cs); | |
| 6767 |
1/2✓ Branch 0 taken 78071 times.
✗ Branch 1 not taken.
|
78071 | result = entry->val_str(&null_value, &str_value, decimals); |
| 6768 | |||
| 6769 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 78069 times.
|
78071 | if (null_value) { |
| 6770 | 2 | str_value.set_quick(nullptr, 0, cs); | |
| 6771 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | return set_field_to_null_with_conversions(field, no_conversions); |
| 6772 | } | ||
| 6773 | |||
| 6774 | /* NOTE: If null_value == false, "result" must be not NULL. */ | ||
| 6775 | |||
| 6776 |
1/2✓ Branch 0 taken 78069 times.
✗ Branch 1 not taken.
|
78069 | field->set_notnull(); |
| 6777 |
1/2✓ Branch 0 taken 78069 times.
✗ Branch 1 not taken.
|
78069 | error = field->store(result->ptr(), result->length(), cs); |
| 6778 | 78069 | str_value.set_quick(nullptr, 0, cs); | |
| 6779 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 2886487 times.
|
2886517 | } else if (result_type() == REAL_RESULT) { |
| 6780 | 30 | double nr = entry->val_real(&null_value); | |
| 6781 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
|
30 | if (null_value) return set_field_to_null(field); |
| 6782 | 30 | field->set_notnull(); | |
| 6783 | 30 | error = field->store(nr); | |
| 6784 |
2/2✓ Branch 0 taken 23 times.
✓ Branch 1 taken 2886464 times.
|
2886487 | } else if (result_type() == DECIMAL_RESULT) { |
| 6785 | 23 | my_decimal decimal_value; | |
| 6786 |
1/2✓ Branch 0 taken 23 times.
✗ Branch 1 not taken.
|
23 | my_decimal *val = entry->val_decimal(&null_value, &decimal_value); |
| 6787 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 21 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
23 | if (null_value) return set_field_to_null(field); |
| 6788 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | field->set_notnull(); |
| 6789 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | error = field->store_decimal(val); |
| 6790 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 2 times.
|
23 | } else { |
| 6791 | 2886464 | longlong nr = entry->val_int(&null_value); | |
| 6792 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2886461 times.
|
2886464 | if (null_value) |
| 6793 | 3 | return set_field_to_null_with_conversions(field, no_conversions); | |
| 6794 | 2886461 | field->set_notnull(); | |
| 6795 | 2886461 | error = field->store(nr, unsigned_flag); | |
| 6796 | } | ||
| 6797 | 2964581 | return error; | |
| 6798 | } | ||
| 6799 | |||
| 6800 | 1773282 | String *Item_func_get_user_var::val_str(String *str) { | |
| 6801 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1773282 times.
|
1773282 | assert(fixed); |
| 6802 |
1/2✓ Branch 0 taken 1773313 times.
✗ Branch 1 not taken.
|
1773282 | DBUG_TRACE; |
| 6803 |
1/2✓ Branch 0 taken 1773313 times.
✗ Branch 1 not taken.
|
1773313 | THD *thd = current_thd; |
| 6804 |
3/4✓ Branch 0 taken 413939 times.
✓ Branch 1 taken 1359374 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1773314 times.
|
2187253 | if (var_entry == nullptr && |
| 6805 |
2/4✓ Branch 0 taken 413940 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 413940 times.
|
413939 | get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry)) |
| 6806 | ✗ | return error_str(); | |
| 6807 |
3/4✓ Branch 0 taken 393 times.
✓ Branch 1 taken 1772921 times.
✓ Branch 2 taken 393 times.
✗ Branch 3 not taken.
|
1773314 | if (var_entry == nullptr) return error_str(); // No such variable |
| 6808 |
1/2✓ Branch 0 taken 1772899 times.
✗ Branch 1 not taken.
|
1772921 | String *res = var_entry->val_str(&null_value, str, decimals); |
| 6809 |
7/8✓ Branch 0 taken 1769207 times.
✓ Branch 1 taken 3692 times.
✓ Branch 2 taken 1769195 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2587 times.
✓ Branch 5 taken 1766608 times.
✓ Branch 6 taken 2587 times.
✓ Branch 7 taken 1770300 times.
|
1772899 | if (res && !my_charset_same(res->charset(), collation.collation)) { |
| 6810 | 2587 | String tmpstr; | |
| 6811 | uint error; | ||
| 6812 |
1/2✓ Branch 0 taken 2587 times.
✗ Branch 1 not taken.
|
2587 | if (tmpstr.copy(res->ptr(), res->length(), res->charset(), |
| 6813 |
3/4✓ Branch 0 taken 2587 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 2585 times.
|
5174 | collation.collation, &error) || |
| 6814 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2585 times.
|
2587 | error > 0) { |
| 6815 | char tmp[32]; | ||
| 6816 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | convert_to_printable(tmp, sizeof(tmp), res->ptr(), res->length(), |
| 6817 | res->charset(), 6); | ||
| 6818 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | my_error(ER_INVALID_CHARACTER_STRING, MYF(0), collation.collation->csname, |
| 6819 | tmp); | ||
| 6820 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | return error_str(); |
| 6821 | } | ||
| 6822 |
2/6✓ Branch 0 taken 2585 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2585 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
2585 | if (str->copy(tmpstr)) return error_str(); |
| 6823 | 2585 | return str; | |
| 6824 | 2587 | } | |
| 6825 | 1770300 | return res; | |
| 6826 | 1773280 | } | |
| 6827 | |||
| 6828 | 581266 | double Item_func_get_user_var::val_real() { | |
| 6829 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 581266 times.
|
581266 | assert(fixed); |
| 6830 | THD *thd; | ||
| 6831 |
4/6✓ Branch 0 taken 9430 times.
✓ Branch 1 taken 571836 times.
✓ Branch 2 taken 9430 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 581266 times.
|
590696 | if (var_entry == nullptr && (thd = current_thd) && |
| 6832 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9430 times.
|
9430 | get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry)) |
| 6833 | ✗ | return 0.0; | |
| 6834 |
2/2✓ Branch 0 taken 43 times.
✓ Branch 1 taken 581223 times.
|
581266 | if (var_entry == nullptr) return 0.0; // No such variable |
| 6835 | 581223 | return (var_entry->val_real(&null_value)); | |
| 6836 | } | ||
| 6837 | |||
| 6838 | 91800 | my_decimal *Item_func_get_user_var::val_decimal(my_decimal *dec) { | |
| 6839 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 91800 times.
|
91800 | assert(fixed); |
| 6840 | THD *thd; | ||
| 6841 |
4/6✓ Branch 0 taken 1786 times.
✓ Branch 1 taken 90014 times.
✓ Branch 2 taken 1786 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 91800 times.
|
93586 | if (var_entry == nullptr && (thd = current_thd) && |
| 6842 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1786 times.
|
1786 | get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry)) |
| 6843 | ✗ | return nullptr; | |
| 6844 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 91798 times.
|
91800 | if (var_entry == nullptr) return nullptr; |
| 6845 | 91798 | return var_entry->val_decimal(&null_value, dec); | |
| 6846 | } | ||
| 6847 | |||
| 6848 | 8416249 | longlong Item_func_get_user_var::val_int() { | |
| 6849 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8416249 times.
|
8416249 | assert(fixed); |
| 6850 | THD *thd; | ||
| 6851 |
5/6✓ Branch 0 taken 793635 times.
✓ Branch 1 taken 7622614 times.
✓ Branch 2 taken 793573 times.
✓ Branch 3 taken 66 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 8416288 times.
|
9209857 | if (var_entry == nullptr && (thd = current_thd) && |
| 6852 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 793608 times.
|
793573 | get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry)) |
| 6853 | ✗ | return 0LL; | |
| 6854 |
2/2✓ Branch 0 taken 1537 times.
✓ Branch 1 taken 8414751 times.
|
8416288 | if (var_entry == nullptr) return 0LL; // No such variable |
| 6855 | /* | ||
| 6856 | See bug#27969934 NO WARNING WHEN CAST OF USER VARIABLE | ||
| 6857 | TO NUMBER GOES WRONG. | ||
| 6858 | */ | ||
| 6859 | 8414751 | return var_entry->val_int(&null_value); | |
| 6860 | } | ||
| 6861 | |||
| 6862 | 190311 | const CHARSET_INFO *Item_func_get_user_var::charset_for_protocol() { | |
| 6863 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 190311 times.
|
190311 | assert(fixed); |
| 6864 | THD *thd; | ||
| 6865 | /* | ||
| 6866 | If the query reads the value of the variable's charset it depends on this | ||
| 6867 | variable, so the user var may need to be stored in the binlog: so we call | ||
| 6868 | get_var_with_binlog. | ||
| 6869 | */ | ||
| 6870 |
4/6✓ Branch 0 taken 95418 times.
✓ Branch 1 taken 94893 times.
✓ Branch 2 taken 95418 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 190311 times.
|
285729 | if (var_entry == nullptr && (thd = current_thd) && |
| 6871 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 95418 times.
|
95418 | get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry)) |
| 6872 | ✗ | return &my_charset_bin; | |
| 6873 |
2/2✓ Branch 0 taken 320 times.
✓ Branch 1 taken 189991 times.
|
190311 | if (var_entry == nullptr) return &my_charset_bin; // No such variable |
| 6874 | // @todo WL#6570 Should we return collation of Item node or variable entry? | ||
| 6875 |
2/2✓ Branch 0 taken 52611 times.
✓ Branch 1 taken 137380 times.
|
189991 | return result_type() == STRING_RESULT ? collation.collation : &my_charset_bin; |
| 6876 | } | ||
| 6877 | |||
| 6878 | /** | ||
| 6879 | Get variable by name and, if necessary, put the record of variable | ||
| 6880 | use into the binary log. | ||
| 6881 | |||
| 6882 | When a user variable is invoked from an update query (INSERT, UPDATE etc), | ||
| 6883 | stores this variable and its value in thd->user_var_events, so that it can be | ||
| 6884 | written to the binlog (will be written just before the query is written, see | ||
| 6885 | log.cc). | ||
| 6886 | |||
| 6887 | @param thd Current session. | ||
| 6888 | @param sql_command The command the variable participates in. | ||
| 6889 | @param name Variable name | ||
| 6890 | @param[out] out_entry variable structure or NULL. The pointer is set | ||
| 6891 | regardless of whether function succeeded or not. | ||
| 6892 | |||
| 6893 | @retval | ||
| 6894 | 0 OK | ||
| 6895 | @retval | ||
| 6896 | 1 Failed to put appropriate record into binary log | ||
| 6897 | |||
| 6898 | */ | ||
| 6899 | |||
| 6900 | 1314166 | static int get_var_with_binlog(THD *thd, enum_sql_command sql_command, | |
| 6901 | const Name_string &name, | ||
| 6902 | user_var_entry **out_entry) { | ||
| 6903 | Binlog_user_var_event *user_var_event; | ||
| 6904 | user_var_entry *var_entry; | ||
| 6905 | |||
| 6906 | /* Protects thd->user_vars. */ | ||
| 6907 |
1/2✓ Branch 0 taken 1314131 times.
✗ Branch 1 not taken.
|
1314166 | mysql_mutex_lock(&thd->LOCK_thd_data); |
| 6908 |
1/2✓ Branch 0 taken 1314128 times.
✗ Branch 1 not taken.
|
1314131 | var_entry = get_variable(thd, name, nullptr); |
| 6909 |
1/2✓ Branch 0 taken 1314235 times.
✗ Branch 1 not taken.
|
1314128 | mysql_mutex_unlock(&thd->LOCK_thd_data); |
| 6910 | |||
| 6911 | 1314235 | *out_entry = var_entry; | |
| 6912 | |||
| 6913 | /* | ||
| 6914 | In cases when this function is called for a sub-statement, we can't | ||
| 6915 | rely on OPTION_BIN_LOG flag in THD::variables.option_bits bitmap | ||
| 6916 | to determine whether binary logging is turned on, as this bit can be | ||
| 6917 | cleared before executing sub-statement. So instead we have to look | ||
| 6918 | at THD::variables::sql_log_bin member. | ||
| 6919 | */ | ||
| 6920 |
4/4✓ Branch 0 taken 1257714 times.
✓ Branch 1 taken 56483 times.
✓ Branch 2 taken 1192941 times.
✓ Branch 3 taken 64773 times.
|
1314235 | bool log_on = mysql_bin_log.is_open() && thd->variables.sql_log_bin; |
| 6921 | |||
| 6922 | /* | ||
| 6923 | Any reference to user-defined variable which is done from stored | ||
| 6924 | function or trigger affects their execution and the execution of the | ||
| 6925 | calling statement. We must log all such variables even if they are | ||
| 6926 | not involved in table-updating statements. | ||
| 6927 | */ | ||
| 6928 |
9/10✓ Branch 0 taken 1192943 times.
✓ Branch 1 taken 121254 times.
✓ Branch 2 taken 1192946 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 942169 times.
✓ Branch 5 taken 250777 times.
✓ Branch 6 taken 900913 times.
✓ Branch 7 taken 41256 times.
✓ Branch 8 taken 1022168 times.
✓ Branch 9 taken 292032 times.
|
1314197 | if (!(log_on && (is_update_query(sql_command) || thd->in_sub_stmt))) return 0; |
| 6929 | |||
| 6930 |
2/2✓ Branch 0 taken 46 times.
✓ Branch 1 taken 291986 times.
|
292032 | if (var_entry == nullptr) { |
| 6931 | /* | ||
| 6932 | If the variable does not exist, it's NULL, but we want to create it so | ||
| 6933 | that it gets into the binlog (if it didn't, the slave could be | ||
| 6934 | influenced by a variable of the same name previously set by another | ||
| 6935 | thread). | ||
| 6936 | We create it like if it had been explicitly set with SET before. | ||
| 6937 | The 'new' mimics what sql_yacc.yy does when 'SET @a=10;'. | ||
| 6938 | sql_set_variables() is what is called from 'case SQLCOM_SET_OPTION' | ||
| 6939 | in dispatch_command()). Instead of building a one-element list to pass to | ||
| 6940 | sql_set_variables(), we could instead manually call check() and update(); | ||
| 6941 | this would save memory and time; but calling sql_set_variables() makes | ||
| 6942 | one unique place to maintain (sql_set_variables()). | ||
| 6943 | |||
| 6944 | Manipulation with lex is necessary since free_underlaid_joins | ||
| 6945 | is going to release memory belonging to the main query. | ||
| 6946 | */ | ||
| 6947 | |||
| 6948 | 46 | List<set_var_base> tmp_var_list; | |
| 6949 |
1/2✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
|
46 | LEX *sav_lex = thd->lex, lex_tmp; |
| 6950 | 46 | thd->lex = &lex_tmp; | |
| 6951 |
1/2✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
|
46 | lex_start(thd); |
| 6952 |
2/4✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 46 times.
✗ Branch 3 not taken.
|
92 | tmp_var_list.push_back(new (thd->mem_root) set_var_user( |
| 6953 |
3/6✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 46 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 46 times.
✗ Branch 5 not taken.
|
138 | new Item_func_set_user_var(name, new Item_null()))); |
| 6954 | /* Create the variable */ | ||
| 6955 |
2/4✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 46 times.
|
46 | if (sql_set_variables(thd, &tmp_var_list, false)) { |
| 6956 | ✗ | thd->lex = sav_lex; | |
| 6957 | ✗ | return 1; | |
| 6958 | } | ||
| 6959 | 46 | thd->lex = sav_lex; | |
| 6960 |
1/2✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
|
46 | mysql_mutex_lock(&thd->LOCK_thd_data); |
| 6961 |
1/2✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
|
46 | var_entry = get_variable(thd, name, nullptr); |
| 6962 |
1/2✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
|
46 | mysql_mutex_unlock(&thd->LOCK_thd_data); |
| 6963 | |||
| 6964 | 46 | *out_entry = var_entry; | |
| 6965 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.
|
46 | if (var_entry == nullptr) return 1; |
| 6966 |
5/6✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 234635 times.
✓ Branch 3 taken 57357 times.
✓ Branch 4 taken 57409 times.
✓ Branch 5 taken 234583 times.
|
526667 | } else if (var_entry->used_query_id() == thd->query_id || |
| 6967 |
3/4✓ Branch 0 taken 234635 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 52 times.
✓ Branch 3 taken 234583 times.
|
234635 | mysql_bin_log.is_query_in_union(thd, var_entry->used_query_id())) { |
| 6968 | /* | ||
| 6969 | If this variable was already stored in user_var_events by this query | ||
| 6970 | (because it's used in more than one place in the query), don't store | ||
| 6971 | it. | ||
| 6972 | */ | ||
| 6973 | 57409 | return 0; | |
| 6974 | } | ||
| 6975 | |||
| 6976 | /* | ||
| 6977 | First we need to store value of var_entry, when the next situation | ||
| 6978 | appears: | ||
| 6979 | > set @a:=1; | ||
| 6980 | > insert into t1 values (@a), (@a:=@a+1), (@a:=@a+1); | ||
| 6981 | We have to write to binlog value @a= 1. | ||
| 6982 | |||
| 6983 | We allocate the user_var_event on user_var_events_alloc pool, not on | ||
| 6984 | the this-statement-execution pool because in SPs user_var_event objects | ||
| 6985 | may need to be valid after current [SP] statement execution pool is | ||
| 6986 | destroyed. | ||
| 6987 | */ | ||
| 6988 | 234629 | size_t size = ALIGN_SIZE(sizeof(Binlog_user_var_event)) + var_entry->length(); | |
| 6989 | 234629 | if (!(user_var_event = | |
| 6990 |
2/4✓ Branch 0 taken 234629 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 234629 times.
|
234629 | (Binlog_user_var_event *)thd->user_var_events_alloc->Alloc(size))) |
| 6991 | ✗ | return 1; | |
| 6992 | |||
| 6993 | 234629 | user_var_event->value = | |
| 6994 | 234629 | (char *)user_var_event + ALIGN_SIZE(sizeof(Binlog_user_var_event)); | |
| 6995 | 234629 | user_var_event->user_var_event = var_entry; | |
| 6996 | 234629 | user_var_event->type = var_entry->type(); | |
| 6997 | 234629 | user_var_event->charset_number = var_entry->collation.collation->number; | |
| 6998 | 234629 | user_var_event->unsigned_flag = var_entry->unsigned_flag; | |
| 6999 |
2/2✓ Branch 0 taken 2752 times.
✓ Branch 1 taken 231877 times.
|
234629 | if (!var_entry->ptr()) { |
| 7000 | /* NULL value*/ | ||
| 7001 | 2752 | user_var_event->length = 0; | |
| 7002 | 2752 | user_var_event->value = nullptr; | |
| 7003 | } else { | ||
| 7004 | // Avoid memcpy of a my_decimal object, use copy CTOR instead. | ||
| 7005 | 231877 | user_var_event->length = var_entry->length(); | |
| 7006 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 231817 times.
|
231877 | if (user_var_event->type == DECIMAL_RESULT) { |
| 7007 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 60 times.
|
60 | assert(var_entry->length() == sizeof(my_decimal)); |
| 7008 | const my_decimal *dec = static_cast<const my_decimal *>( | ||
| 7009 | 60 | static_cast<const void *>(var_entry->ptr())); | |
| 7010 | 60 | dec->sanity_check(); | |
| 7011 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | new (user_var_event->value) my_decimal(*dec); |
| 7012 | } else | ||
| 7013 | 231817 | memcpy(user_var_event->value, var_entry->ptr(), var_entry->length()); | |
| 7014 | } | ||
| 7015 | // Mark that this variable has been used by this query | ||
| 7016 | 234629 | var_entry->set_used_query_id(thd->query_id); | |
| 7017 |
2/4✓ Branch 0 taken 234629 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 234629 times.
|
234629 | if (thd->user_var_events.push_back(user_var_event)) return 1; |
| 7018 | |||
| 7019 | 234629 | return 0; | |
| 7020 | } | ||
| 7021 | |||
| 7022 | 745413 | bool Item_func_get_user_var::resolve_type(THD *thd) { | |
| 7023 | 745413 | set_nullable(true); | |
| 7024 | |||
| 7025 | /* | ||
| 7026 | @todo WL#6570 change has effects: | ||
| 7027 | - bad: in packet.test (see comment there), ps_<n><engine>.test | ||
| 7028 | (e.g. ps_5merge.test) (see comment in include/ps_conv.inc), | ||
| 7029 | ps_w_max_indexes_64 | ||
| 7030 | - good: type_temporal_fractional.test (see comment in that file) | ||
| 7031 | - fixes failure of: sysschema.pr_statement_performance_analyzer and | ||
| 7032 | sysschema.format_statement. | ||
| 7033 | Don't forget to grep for "WL#6570" in the whole tree, including mtr | ||
| 7034 | tests. | ||
| 7035 | */ | ||
| 7036 | 745413 | used_tables_cache = | |
| 7037 |
2/2✓ Branch 0 taken 2761 times.
✓ Branch 1 taken 742652 times.
|
745413 | thd->lex->locate_var_assignment(name) ? RAND_TABLE_BIT : INNER_TABLE_BIT; |
| 7038 | |||
| 7039 | 745413 | mysql_mutex_lock(&thd->LOCK_thd_data); | |
| 7040 | 745413 | var_entry = get_variable(thd, name, nullptr); | |
| 7041 | 745414 | mysql_mutex_unlock(&thd->LOCK_thd_data); | |
| 7042 | |||
| 7043 |
2/2✓ Branch 0 taken 731668 times.
✓ Branch 1 taken 13746 times.
|
745414 | if (var_entry != nullptr) { |
| 7044 | // Variable exists - assign type information from the entry. | ||
| 7045 | 731668 | m_cached_result_type = var_entry->type(); | |
| 7046 | |||
| 7047 |
4/5✓ Branch 0 taken 6071 times.
✓ Branch 1 taken 401455 times.
✓ Branch 2 taken 317741 times.
✓ Branch 3 taken 6400 times.
✗ Branch 4 not taken.
|
731667 | switch (m_cached_result_type) { |
| 7048 | 6071 | case REAL_RESULT: | |
| 7049 | 6071 | set_data_type_double(); | |
| 7050 | 6071 | break; | |
| 7051 | 401455 | case INT_RESULT: | |
| 7052 | 401455 | set_data_type_longlong(); | |
| 7053 | 401454 | unsigned_flag = var_entry->unsigned_flag; | |
| 7054 | 401454 | break; | |
| 7055 | 317741 | case STRING_RESULT: | |
| 7056 | 317741 | set_data_type_string(uint32(MAX_BLOB_WIDTH - 1), var_entry->collation); | |
| 7057 | 317741 | break; | |
| 7058 | 6400 | case DECIMAL_RESULT: | |
| 7059 | 6400 | set_data_type_decimal(DECIMAL_MAX_PRECISION, DECIMAL_MAX_SCALE); | |
| 7060 | 6400 | break; | |
| 7061 | ✗ | case ROW_RESULT: // Keep compiler happy | |
| 7062 | default: | ||
| 7063 | ✗ | assert(0); | |
| 7064 | break; | ||
| 7065 | } | ||
| 7066 | |||
| 7067 | // Override collation for all data types | ||
| 7068 | 731666 | collation.set(var_entry->collation); | |
| 7069 | } else { | ||
| 7070 | // Unknown user variable, assign expected type from context. | ||
| 7071 | 13746 | null_value = true; | |
| 7072 | } | ||
| 7073 | 745412 | collation.set(DERIVATION_IMPLICIT); | |
| 7074 | |||
| 7075 | // Refresh the variable entry during execution with proper binlogging. | ||
| 7076 | 745412 | var_entry = nullptr; | |
| 7077 | |||
| 7078 | 745412 | return false; | |
| 7079 | } | ||
| 7080 | |||
| 7081 | 13742 | bool Item_func_get_user_var::propagate_type(THD *, | |
| 7082 | const Type_properties &type) { | ||
| 7083 | /* | ||
| 7084 | If the type is temporal: user variables don't support that type; so, we | ||
| 7085 | use a VARCHAR instead. Same for JSON and GEOMETRY. | ||
| 7086 | BIT and YEAR types are represented with LONGLONG. | ||
| 7087 | */ | ||
| 7088 |
10/13✓ Branch 0 taken 13262 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 12 times.
✓ Branch 5 taken 431 times.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 3 times.
✓ Branch 8 taken 17 times.
✓ Branch 9 taken 4 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 7 times.
✗ Branch 12 not taken.
|
13742 | switch (type.m_type) { |
| 7089 | 13262 | case MYSQL_TYPE_TINY: | |
| 7090 | case MYSQL_TYPE_SHORT: | ||
| 7091 | case MYSQL_TYPE_INT24: | ||
| 7092 | case MYSQL_TYPE_LONG: | ||
| 7093 | case MYSQL_TYPE_LONGLONG: | ||
| 7094 | 13262 | set_data_type_longlong(); | |
| 7095 | 13262 | unsigned_flag = type.m_unsigned_flag; | |
| 7096 | 13262 | break; | |
| 7097 | 1 | case MYSQL_TYPE_BIT: | |
| 7098 | 1 | set_data_type_longlong(); | |
| 7099 | 1 | unsigned_flag = true; | |
| 7100 | 1 | break; | |
| 7101 | ✗ | case MYSQL_TYPE_YEAR: | |
| 7102 | ✗ | set_data_type_longlong(); | |
| 7103 | ✗ | break; | |
| 7104 | 4 | case MYSQL_TYPE_NEWDECIMAL: | |
| 7105 | case MYSQL_TYPE_DECIMAL: | ||
| 7106 | 4 | set_data_type_decimal(DECIMAL_MAX_PRECISION, DECIMAL_MAX_SCALE); | |
| 7107 | 4 | break; | |
| 7108 | 12 | case MYSQL_TYPE_FLOAT: | |
| 7109 | case MYSQL_TYPE_DOUBLE: | ||
| 7110 | 12 | set_data_type_double(); | |
| 7111 | 12 | break; | |
| 7112 | 431 | case MYSQL_TYPE_VARCHAR: | |
| 7113 | case MYSQL_TYPE_VAR_STRING: | ||
| 7114 | case MYSQL_TYPE_STRING: | ||
| 7115 | case MYSQL_TYPE_ENUM: | ||
| 7116 | case MYSQL_TYPE_SET: | ||
| 7117 | case MYSQL_TYPE_NULL: | ||
| 7118 | // Parameter type is VARCHAR of largest possible size | ||
| 7119 | 431 | set_data_type_string(65535U / type.m_collation.collation->mbmaxlen, | |
| 7120 | 431 | type.m_collation); | |
| 7121 | 431 | break; | |
| 7122 | 1 | case MYSQL_TYPE_GEOMETRY: | |
| 7123 | 1 | set_data_type_string(MAX_BLOB_WIDTH, type.m_collation); | |
| 7124 | 1 | break; | |
| 7125 | 3 | case MYSQL_TYPE_JSON: | |
| 7126 | 3 | set_data_type_string(MAX_BLOB_WIDTH, type.m_collation); | |
| 7127 | 3 | break; | |
| 7128 | 17 | case MYSQL_TYPE_TINY_BLOB: | |
| 7129 | case MYSQL_TYPE_MEDIUM_BLOB: | ||
| 7130 | case MYSQL_TYPE_LONG_BLOB: | ||
| 7131 | case MYSQL_TYPE_BLOB: | ||
| 7132 | // Parameter type is BLOB of largest possible size | ||
| 7133 | 17 | set_data_type_string(MAX_BLOB_WIDTH, type.m_collation); | |
| 7134 | 17 | break; | |
| 7135 | 4 | case MYSQL_TYPE_DATETIME: | |
| 7136 | case MYSQL_TYPE_DATETIME2: | ||
| 7137 | case MYSQL_TYPE_TIMESTAMP: | ||
| 7138 | case MYSQL_TYPE_TIMESTAMP2: | ||
| 7139 | 4 | set_data_type_string(26, type.m_collation); | |
| 7140 | 4 | break; | |
| 7141 | ✗ | case MYSQL_TYPE_DATE: | |
| 7142 | case MYSQL_TYPE_NEWDATE: | ||
| 7143 | ✗ | set_data_type_string(10, type.m_collation); | |
| 7144 | ✗ | break; | |
| 7145 | 7 | case MYSQL_TYPE_TIME: | |
| 7146 | case MYSQL_TYPE_TIME2: | ||
| 7147 | 7 | set_data_type_string(15, type.m_collation); | |
| 7148 | 7 | break; | |
| 7149 | ✗ | default: | |
| 7150 | ✗ | assert(false); | |
| 7151 | } | ||
| 7152 | // User variables have implicit derivation | ||
| 7153 | 13742 | collation.set(DERIVATION_IMPLICIT); | |
| 7154 | |||
| 7155 | // @todo - when result_type is refactored, this may not be necessary | ||
| 7156 | 13742 | m_cached_result_type = type_to_result(data_type()); | |
| 7157 | |||
| 7158 | 13742 | return false; | |
| 7159 | } | ||
| 7160 | |||
| 7161 | 1352580 | void Item_func_get_user_var::cleanup() { | |
| 7162 | 1352580 | Item_func::cleanup(); | |
| 7163 | /* | ||
| 7164 | Ensure that a valid user variable object is rebound on next execution. See | ||
| 7165 | comment in Item_func_set_user_var::cleanup(). | ||
| 7166 | */ | ||
| 7167 | 1352637 | var_entry = nullptr; | |
| 7168 | 1352637 | } | |
| 7169 | |||
| 7170 | 3897246 | enum Item_result Item_func_get_user_var::result_type() const { | |
| 7171 | 3897246 | return m_cached_result_type; | |
| 7172 | } | ||
| 7173 | |||
| 7174 | 674 | void Item_func_get_user_var::print(const THD *thd, String *str, | |
| 7175 | enum_query_type) const { | ||
| 7176 | 674 | str->append(STRING_WITH_LEN("(@")); | |
| 7177 | 674 | append_identifier(thd, str, name.ptr(), name.length()); | |
| 7178 | 674 | str->append(')'); | |
| 7179 | 674 | } | |
| 7180 | |||
| 7181 | 24402 | bool Item_func_get_user_var::eq(const Item *item, bool) const { | |
| 7182 | /* Assume we don't have rtti */ | ||
| 7183 |
2/2✓ Branch 0 taken 8496 times.
✓ Branch 1 taken 15906 times.
|
24402 | if (this == item) return true; // Same item is same. |
| 7184 | /* Check if other type is also a get_user_var() object */ | ||
| 7185 |
4/4✓ Branch 0 taken 8741 times.
✓ Branch 1 taken 7165 times.
✓ Branch 2 taken 14318 times.
✓ Branch 3 taken 1588 times.
|
24647 | if (item->type() != FUNC_ITEM || |
| 7186 |
2/2✓ Branch 0 taken 7153 times.
✓ Branch 1 taken 1588 times.
|
8741 | down_cast<const Item_func *>(item)->functype() != functype()) |
| 7187 | 14318 | return false; | |
| 7188 | const Item_func_get_user_var *other = | ||
| 7189 | 1588 | down_cast<const Item_func_get_user_var *>(item); | |
| 7190 | 1588 | return name.eq_bin(other->name); | |
| 7191 | } | ||
| 7192 | |||
| 7193 | 13717 | bool Item_func_get_user_var::set_value(THD *thd, sp_rcontext * /*ctx*/, | |
| 7194 | Item **it) { | ||
| 7195 |
2/4✓ Branch 0 taken 13717 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13717 times.
✗ Branch 3 not taken.
|
13717 | Item_func_set_user_var *suv = new Item_func_set_user_var(name, *it); |
| 7196 | /* | ||
| 7197 | Item_func_set_user_var is not fixed after construction, call | ||
| 7198 | fix_fields(). | ||
| 7199 | */ | ||
| 7200 |
3/6✓ Branch 0 taken 13717 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13717 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 13717 times.
✗ Branch 5 not taken.
|
27434 | return (!suv || suv->fix_fields(thd, it) || suv->check(false) || |
| 7201 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13717 times.
|
27434 | suv->update()); |
| 7202 | } | ||
| 7203 | |||
| 7204 | 61 | bool Item_user_var_as_out_param::fix_fields(THD *thd, Item **ref) { | |
| 7205 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | assert(fixed == 0); |
| 7206 | |||
| 7207 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | assert(thd->lex->sql_command == SQLCOM_LOAD); |
| 7208 | auto exchange_cs = | ||
| 7209 | 61 | down_cast<Sql_cmd_load_table *>(thd->lex->m_sql_cmd)->m_exchange.cs; | |
| 7210 | /* | ||
| 7211 | Let us set the same collation which is used for loading | ||
| 7212 | of fields in LOAD DATA INFILE. | ||
| 7213 | (Since Item_user_var_as_out_param is used only there). | ||
| 7214 | */ | ||
| 7215 | 61 | const CHARSET_INFO *cs = | |
| 7216 |
2/2✓ Branch 0 taken 59 times.
✓ Branch 1 taken 2 times.
|
61 | exchange_cs ? exchange_cs : thd->variables.collation_database; |
| 7217 | |||
| 7218 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | if (Item::fix_fields(thd, ref)) return true; |
| 7219 | |||
| 7220 | /* Protects thd->user_vars. */ | ||
| 7221 | 61 | mysql_mutex_lock(&thd->LOCK_thd_data); | |
| 7222 | 61 | entry = get_variable(thd, name, cs); | |
| 7223 |
1/2✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
|
61 | if (entry != nullptr) entry->set_type(STRING_RESULT); |
| 7224 | 61 | mysql_mutex_unlock(&thd->LOCK_thd_data); | |
| 7225 | |||
| 7226 | 61 | return entry == nullptr; | |
| 7227 | } | ||
| 7228 | |||
| 7229 | 26 | void Item_user_var_as_out_param::set_null_value(const CHARSET_INFO *) { | |
| 7230 | 26 | entry->lock(); | |
| 7231 | 26 | entry->set_null_value(STRING_RESULT); | |
| 7232 | 26 | entry->unlock(); | |
| 7233 | 26 | } | |
| 7234 | |||
| 7235 | 838 | void Item_user_var_as_out_param::set_value(const char *str, size_t length, | |
| 7236 | const CHARSET_INFO *cs) { | ||
| 7237 | 838 | entry->lock(); | |
| 7238 | 838 | entry->store(str, length, STRING_RESULT, cs, DERIVATION_IMPLICIT, | |
| 7239 | false /* unsigned_arg */); | ||
| 7240 | 838 | entry->unlock(); | |
| 7241 | 838 | } | |
| 7242 | |||
| 7243 | ✗ | double Item_user_var_as_out_param::val_real() { | |
| 7244 | ✗ | assert(0); | |
| 7245 | return 0.0; | ||
| 7246 | } | ||
| 7247 | |||
| 7248 | ✗ | longlong Item_user_var_as_out_param::val_int() { | |
| 7249 | ✗ | assert(0); | |
| 7250 | return 0; | ||
| 7251 | } | ||
| 7252 | |||
| 7253 | ✗ | String *Item_user_var_as_out_param::val_str(String *) { | |
| 7254 | ✗ | assert(0); | |
| 7255 | return nullptr; | ||
| 7256 | } | ||
| 7257 | |||
| 7258 | ✗ | my_decimal *Item_user_var_as_out_param::val_decimal(my_decimal *) { | |
| 7259 | ✗ | assert(0); | |
| 7260 | return nullptr; | ||
| 7261 | } | ||
| 7262 | |||
| 7263 | 14 | void Item_user_var_as_out_param::print(const THD *thd, String *str, | |
| 7264 | enum_query_type) const { | ||
| 7265 | 14 | str->append('@'); | |
| 7266 | 14 | append_identifier(thd, str, name.ptr(), name.length()); | |
| 7267 | 14 | } | |
| 7268 | |||
| 7269 | 581941 | Item_func_get_system_var::Item_func_get_system_var( | |
| 7270 | 581941 | const System_variable_tracker &var_tracker, enum_var_type scope) | |
| 7271 |
1/2✓ Branch 0 taken 581941 times.
✗ Branch 1 not taken.
|
581941 | : var_scope{scope}, cache_present{0}, var_tracker{var_tracker} { |
| 7272 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 581941 times.
|
581941 | assert(scope != OPT_DEFAULT); |
| 7273 | 581941 | } | |
| 7274 | |||
| 7275 | 506898 | bool Item_func_get_system_var::resolve_type(THD *) { | |
| 7276 | 506898 | set_nullable(true); | |
| 7277 | |||
| 7278 |
5/6✓ Branch 0 taken 150230 times.
✓ Branch 1 taken 544 times.
✓ Branch 2 taken 246656 times.
✓ Branch 3 taken 109145 times.
✓ Branch 4 taken 324 times.
✗ Branch 5 not taken.
|
506899 | switch (var_tracker.cached_show_type()) { |
| 7279 | 150230 | case SHOW_LONG: | |
| 7280 | case SHOW_INT: | ||
| 7281 | case SHOW_HA_ROWS: | ||
| 7282 | case SHOW_LONGLONG: | ||
| 7283 | 150230 | set_data_type_longlong(); | |
| 7284 | 150229 | unsigned_flag = true; | |
| 7285 | 150229 | break; | |
| 7286 | 544 | case SHOW_SIGNED_INT: | |
| 7287 | case SHOW_SIGNED_LONG: | ||
| 7288 | case SHOW_SIGNED_LONGLONG: | ||
| 7289 | 544 | set_data_type_longlong(); | |
| 7290 | 544 | unsigned_flag = false; | |
| 7291 | 544 | break; | |
| 7292 | 246656 | case SHOW_CHAR: | |
| 7293 | case SHOW_CHAR_PTR: | ||
| 7294 | case SHOW_LEX_STRING: | ||
| 7295 | 246656 | collation.set(system_charset_info, DERIVATION_SYSCONST); | |
| 7296 | 246657 | set_data_type_string(65535U / collation.collation->mbmaxlen); | |
| 7297 | 246659 | break; | |
| 7298 | 109145 | case SHOW_BOOL: | |
| 7299 | case SHOW_MY_BOOL: | ||
| 7300 | 109145 | set_data_type_longlong(); | |
| 7301 | 109145 | max_length = 1; | |
| 7302 | 109145 | break; | |
| 7303 | 324 | case SHOW_DOUBLE: | |
| 7304 | 324 | set_data_type_double(); | |
| 7305 | // Override decimals and length calculation done above. | ||
| 7306 | 324 | decimals = 6; | |
| 7307 | 324 | max_length = float_length(decimals); | |
| 7308 | 324 | break; | |
| 7309 | ✗ | default: | |
| 7310 | ✗ | my_error(ER_VAR_CANT_BE_READ, MYF(0), var_tracker.get_var_name()); | |
| 7311 | ✗ | return true; | |
| 7312 | } | ||
| 7313 | 506901 | return false; | |
| 7314 | } | ||
| 7315 | |||
| 7316 | 41 | void Item_func_get_system_var::print(const THD *, String *str, | |
| 7317 | enum_query_type) const { | ||
| 7318 | 41 | str->append(item_name); | |
| 7319 | 41 | } | |
| 7320 | |||
| 7321 | 653158 | Audit_global_variable_get_event::Audit_global_variable_get_event( | |
| 7322 | 653158 | THD *thd, Item_func_get_system_var *item, uchar cache_type) | |
| 7323 | 653158 | : m_thd(thd), m_item(item), m_val_type(cache_type) { | |
| 7324 | // Variable is of GLOBAL scope. | ||
| 7325 | 653158 | bool is_global_var = m_item->var_scope == OPT_GLOBAL; | |
| 7326 | |||
| 7327 | // Event is already audited for the same query. | ||
| 7328 | 653158 | bool event_is_audited = | |
| 7329 |
3/4✓ Branch 0 taken 745 times.
✓ Branch 1 taken 652413 times.
✓ Branch 2 taken 745 times.
✗ Branch 3 not taken.
|
653158 | m_item->cache_present != 0 && m_item->used_query_id == m_thd->query_id; |
| 7330 | |||
| 7331 |
4/4✓ Branch 0 taken 543993 times.
✓ Branch 1 taken 109165 times.
✓ Branch 2 taken 543303 times.
✓ Branch 3 taken 690 times.
|
653158 | m_audit_event = (is_global_var && !event_is_audited); |
| 7332 | 653158 | } | |
| 7333 | |||
| 7334 | 653181 | Audit_global_variable_get_event::~Audit_global_variable_get_event() { | |
| 7335 | /* | ||
| 7336 | While converting value to string, integer or real type, if the value is | ||
| 7337 | cached for the types other then m_val_type for intermediate type | ||
| 7338 | conversions then event is already notified. | ||
| 7339 | */ | ||
| 7340 | 653181 | bool event_already_notified = (m_item->cache_present & (~m_val_type)); | |
| 7341 | |||
| 7342 |
4/4✓ Branch 0 taken 543308 times.
✓ Branch 1 taken 109873 times.
✓ Branch 2 taken 513844 times.
✓ Branch 3 taken 29464 times.
|
653181 | if (m_audit_event && !event_already_notified) { |
| 7343 | 513844 | String str; | |
| 7344 | 513844 | String *outStr = nullptr; | |
| 7345 | |||
| 7346 |
4/6✓ Branch 0 taken 320 times.
✓ Branch 1 taken 513524 times.
✓ Branch 2 taken 320 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 513844 times.
✗ Branch 5 not taken.
|
513844 | if (!m_item->cached_null_value || !m_thd->is_error()) { |
| 7347 | 513844 | outStr = &str; | |
| 7348 | |||
| 7349 |
2/4✓ Branch 0 taken 513844 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 513844 times.
✗ Branch 3 not taken.
|
513844 | assert(m_item->cache_present != 0 && |
| 7350 | m_item->used_query_id == m_thd->query_id); | ||
| 7351 | |||
| 7352 |
2/2✓ Branch 0 taken 330277 times.
✓ Branch 1 taken 183567 times.
|
513844 | if (m_item->cache_present & GET_SYS_VAR_CACHE_STRING) |
| 7353 | 330277 | outStr = &m_item->cached_strval; | |
| 7354 |
2/2✓ Branch 0 taken 183416 times.
✓ Branch 1 taken 151 times.
|
183567 | else if (m_item->cache_present & GET_SYS_VAR_CACHE_LONG) |
| 7355 | 183416 | str.set(m_item->cached_llval, m_item->collation.collation); | |
| 7356 |
1/2✓ Branch 0 taken 151 times.
✗ Branch 1 not taken.
|
151 | else if (m_item->cache_present & GET_SYS_VAR_CACHE_DOUBLE) |
| 7357 | 151 | str.set_real(m_item->cached_dval, m_item->decimals, | |
| 7358 | 151 | m_item->collation.collation); | |
| 7359 | } | ||
| 7360 | |||
| 7361 |
2/4✓ Branch 0 taken 513844 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 513844 times.
✗ Branch 3 not taken.
|
1541530 | mysql_audit_notify(m_thd, AUDIT_EVENT(MYSQL_AUDIT_GLOBAL_VARIABLE_GET), |
| 7362 | 513842 | m_item->var_tracker.get_var_name(), | |
| 7363 | 513844 | outStr ? outStr->ptr() : nullptr, | |
| 7364 | 513844 | outStr ? outStr->length() : 0); | |
| 7365 | 513842 | } | |
| 7366 | 653181 | } | |
| 7367 | |||
| 7368 | template <typename T> | ||
| 7369 | 525058 | longlong Item_func_get_system_var::get_sys_var_safe(THD *thd, sys_var *var) { | |
| 7370 | 525058 | T value = {}; | |
| 7371 | { | ||
| 7372 | 525058 | MUTEX_LOCK(lock, &LOCK_global_system_variables); | |
| 7373 | 525058 | std::string_view keycache_name = var_tracker.get_keycache_name(); | |
| 7374 | 525058 | value = | |
| 7375 |
1/2✓ Branch 0 taken 262529 times.
✗ Branch 1 not taken.
|
525058 | *pointer_cast<const T *>(var->value_ptr(thd, var_scope, keycache_name)); |
| 7376 | 525058 | } | |
| 7377 | 525058 | cache_present |= GET_SYS_VAR_CACHE_LONG; | |
| 7378 | 525058 | used_query_id = thd->query_id; | |
| 7379 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 262529 times.
|
525058 | cached_llval = null_value ? 0LL : static_cast<longlong>(value); |
| 7380 | 525058 | cached_null_value = null_value; | |
| 7381 | 525058 | return cached_llval; | |
| 7382 | } | ||
| 7383 | |||
| 7384 | 263014 | longlong Item_func_get_system_var::val_int() { | |
| 7385 |
1/2✓ Branch 0 taken 263015 times.
✗ Branch 1 not taken.
|
263014 | THD *thd = current_thd; |
| 7386 | Audit_global_variable_get_event audit_sys_var(thd, this, | ||
| 7387 |
1/2✓ Branch 0 taken 263016 times.
✗ Branch 1 not taken.
|
263015 | GET_SYS_VAR_CACHE_LONG); |
| 7388 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 263016 times.
|
263016 | assert(fixed); |
| 7389 | |||
| 7390 |
3/4✓ Branch 0 taken 487 times.
✓ Branch 1 taken 262529 times.
✓ Branch 2 taken 487 times.
✗ Branch 3 not taken.
|
263016 | if (cache_present && thd->query_id == used_query_id) { |
| 7391 |
1/2✓ Branch 0 taken 487 times.
✗ Branch 1 not taken.
|
487 | if (cache_present & GET_SYS_VAR_CACHE_LONG) { |
| 7392 | 487 | null_value = cached_null_value; | |
| 7393 | 487 | return cached_llval; | |
| 7394 | ✗ | } else if (cache_present & GET_SYS_VAR_CACHE_DOUBLE) { | |
| 7395 | ✗ | null_value = cached_null_value; | |
| 7396 | ✗ | cached_llval = (longlong)cached_dval; | |
| 7397 | ✗ | cache_present |= GET_SYS_VAR_CACHE_LONG; | |
| 7398 | ✗ | return cached_llval; | |
| 7399 | ✗ | } else if (cache_present & GET_SYS_VAR_CACHE_STRING) { | |
| 7400 | ✗ | null_value = cached_null_value; | |
| 7401 | ✗ | if (!null_value) | |
| 7402 | ✗ | cached_llval = longlong_from_string_with_check( | |
| 7403 | ✗ | cached_strval.charset(), cached_strval.c_ptr(), | |
| 7404 | ✗ | cached_strval.c_ptr() + cached_strval.length(), unsigned_flag); | |
| 7405 | else | ||
| 7406 | ✗ | cached_llval = 0; | |
| 7407 | ✗ | cache_present |= GET_SYS_VAR_CACHE_LONG; | |
| 7408 | ✗ | return cached_llval; | |
| 7409 | } | ||
| 7410 | } | ||
| 7411 | |||
| 7412 | 262531 | auto f = [this, thd](const System_variable_tracker &, | |
| 7413 | 262536 | sys_var *var) -> longlong { | |
| 7414 |
9/12✓ Branch 0 taken 19271 times.
✓ Branch 1 taken 124655 times.
✓ Branch 2 taken 8599 times.
✓ Branch 3 taken 140 times.
✓ Branch 4 taken 271 times.
✓ Branch 5 taken 133 times.
✓ Branch 6 taken 73 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 109387 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 2 times.
✗ Branch 11 not taken.
|
262531 | switch (var->show_type()) { |
| 7415 | 19271 | case SHOW_INT: | |
| 7416 | 19271 | return get_sys_var_safe<uint>(thd, var); | |
| 7417 | 124655 | case SHOW_LONG: | |
| 7418 | 124655 | return get_sys_var_safe<ulong>(thd, var); | |
| 7419 | 8599 | case SHOW_LONGLONG: | |
| 7420 | 8599 | return get_sys_var_safe<ulonglong>(thd, var); | |
| 7421 | 140 | case SHOW_SIGNED_INT: | |
| 7422 | 140 | return get_sys_var_safe<int>(thd, var); | |
| 7423 | 271 | case SHOW_SIGNED_LONG: | |
| 7424 | 271 | return get_sys_var_safe<long>(thd, var); | |
| 7425 | 133 | case SHOW_SIGNED_LONGLONG: | |
| 7426 | 133 | return get_sys_var_safe<longlong>(thd, var); | |
| 7427 | 73 | case SHOW_HA_ROWS: | |
| 7428 | 73 | return get_sys_var_safe<ha_rows>(thd, var); | |
| 7429 | ✗ | case SHOW_BOOL: | |
| 7430 | ✗ | return get_sys_var_safe<bool>(thd, var); | |
| 7431 | 109387 | case SHOW_MY_BOOL: | |
| 7432 | 109387 | return get_sys_var_safe<bool>(thd, var); | |
| 7433 | ✗ | case SHOW_DOUBLE: { | |
| 7434 | ✗ | double dval = val_real(); | |
| 7435 | |||
| 7436 | ✗ | used_query_id = thd->query_id; | |
| 7437 | ✗ | cached_llval = (longlong)dval; | |
| 7438 | ✗ | cache_present |= GET_SYS_VAR_CACHE_LONG; | |
| 7439 | ✗ | return cached_llval; | |
| 7440 | } | ||
| 7441 | 2 | case SHOW_CHAR: | |
| 7442 | case SHOW_CHAR_PTR: | ||
| 7443 | case SHOW_LEX_STRING: { | ||
| 7444 | 2 | String *str_val = val_str(nullptr); | |
| 7445 | // Treat empty strings as NULL, like val_real() does. | ||
| 7446 |
5/6✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1 times.
|
2 | if (str_val && str_val->length()) |
| 7447 | 1 | cached_llval = longlong_from_string_with_check( | |
| 7448 | 1 | system_charset_info, str_val->c_ptr(), | |
| 7449 | 1 | str_val->c_ptr() + str_val->length(), unsigned_flag); | |
| 7450 | else { | ||
| 7451 | 1 | null_value = true; | |
| 7452 | 1 | cached_llval = 0; | |
| 7453 | } | ||
| 7454 | |||
| 7455 | 2 | cache_present |= GET_SYS_VAR_CACHE_LONG; | |
| 7456 | 2 | return cached_llval; | |
| 7457 | } | ||
| 7458 | |||
| 7459 | ✗ | default: | |
| 7460 | ✗ | my_error(ER_VAR_CANT_BE_READ, MYF(0), var->name.str); | |
| 7461 | ✗ | return 0; // keep the compiler happy | |
| 7462 | } | ||
| 7463 | 262529 | }; | |
| 7464 |
1/2✓ Branch 0 taken 262531 times.
✗ Branch 1 not taken.
|
262529 | return var_tracker.access_system_variable<longlong>(thd, f).value_or(0); |
| 7465 | 263018 | } | |
| 7466 | |||
| 7467 | 387097 | String *Item_func_get_system_var::val_str(String *str) { | |
| 7468 |
4/6✓ Branch 0 taken 386083 times.
✓ Branch 1 taken 1027 times.
✓ Branch 2 taken 386086 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 386102 times.
✗ Branch 5 not taken.
|
387097 | DEBUG_SYNC(current_thd, "after_error_checking"); |
| 7469 |
1/2✓ Branch 0 taken 387128 times.
✗ Branch 1 not taken.
|
387129 | THD *thd = current_thd; |
| 7470 | Audit_global_variable_get_event audit_sys_var(thd, this, | ||
| 7471 |
1/2✓ Branch 0 taken 387128 times.
✗ Branch 1 not taken.
|
387128 | GET_SYS_VAR_CACHE_STRING); |
| 7472 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 387128 times.
|
387128 | assert(fixed); |
| 7473 | |||
| 7474 |
3/4✓ Branch 0 taken 252 times.
✓ Branch 1 taken 386876 times.
✓ Branch 2 taken 252 times.
✗ Branch 3 not taken.
|
387128 | if (cache_present && thd->query_id == used_query_id) { |
| 7475 |
2/2✓ Branch 0 taken 242 times.
✓ Branch 1 taken 10 times.
|
252 | if (cache_present & GET_SYS_VAR_CACHE_STRING) { |
| 7476 | 242 | null_value = cached_null_value; | |
| 7477 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 238 times.
|
242 | return null_value ? nullptr : &cached_strval; |
| 7478 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | } else if (cache_present & GET_SYS_VAR_CACHE_LONG) { |
| 7479 | 10 | null_value = cached_null_value; | |
| 7480 |
2/4✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
|
10 | if (!null_value) cached_strval.set(cached_llval, collation.collation); |
| 7481 | 10 | cache_present |= GET_SYS_VAR_CACHE_STRING; | |
| 7482 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | return null_value ? nullptr : &cached_strval; |
| 7483 | ✗ | } else if (cache_present & GET_SYS_VAR_CACHE_DOUBLE) { | |
| 7484 | ✗ | null_value = cached_null_value; | |
| 7485 | ✗ | if (!null_value) | |
| 7486 | ✗ | cached_strval.set_real(cached_dval, decimals, collation.collation); | |
| 7487 | ✗ | cache_present |= GET_SYS_VAR_CACHE_STRING; | |
| 7488 | ✗ | return null_value ? nullptr : &cached_strval; | |
| 7489 | } | ||
| 7490 | } | ||
| 7491 | |||
| 7492 | 386876 | str = &cached_strval; | |
| 7493 | 386876 | null_value = false; | |
| 7494 | |||
| 7495 | 1520914 | auto f = [this, thd, &str](const System_variable_tracker &, sys_var *var) { | |
| 7496 |
2/4✓ Branch 0 taken 360031 times.
✓ Branch 1 taken 26839 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
386861 | switch (var->show_type()) { |
| 7497 | 360031 | case SHOW_CHAR: | |
| 7498 | case SHOW_CHAR_PTR: | ||
| 7499 | case SHOW_LEX_STRING: { | ||
| 7500 | 360031 | mysql_mutex_lock(&LOCK_global_system_variables); | |
| 7501 | const char *cptr = | ||
| 7502 | 360039 | var->show_type() == SHOW_CHAR | |
| 7503 |
2/2✓ Branch 0 taken 202701 times.
✓ Branch 1 taken 157338 times.
|
720078 | ? pointer_cast<const char *>(var->value_ptr( |
| 7504 | 202701 | thd, var_scope, var_tracker.get_keycache_name())) | |
| 7505 | 314676 | : *pointer_cast<const char *const *>(var->value_ptr( | |
| 7506 | 157338 | thd, var_scope, var_tracker.get_keycache_name())); | |
| 7507 |
2/2✓ Branch 0 taken 359650 times.
✓ Branch 1 taken 389 times.
|
360039 | if (cptr) { |
| 7508 | size_t len = | ||
| 7509 | 359650 | var->show_type() == SHOW_LEX_STRING | |
| 7510 |
2/2✓ Branch 0 taken 129 times.
✓ Branch 1 taken 359521 times.
|
359779 | ? (pointer_cast<const LEX_STRING *>(var->value_ptr( |
| 7511 | 129 | thd, var_scope, var_tracker.get_keycache_name()))) | |
| 7512 | ->length | ||
| 7513 | 359521 | : strlen(cptr); | |
| 7514 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 359650 times.
|
359650 | if (str->copy(cptr, len, collation.collation)) { |
| 7515 | ✗ | null_value = true; | |
| 7516 | ✗ | str = nullptr; | |
| 7517 | } | ||
| 7518 | } else { | ||
| 7519 | 389 | null_value = true; | |
| 7520 | 389 | str = nullptr; | |
| 7521 | } | ||
| 7522 | 360039 | mysql_mutex_unlock(&LOCK_global_system_variables); | |
| 7523 | 360039 | break; | |
| 7524 | } | ||
| 7525 | |||
| 7526 | 26839 | case SHOW_INT: | |
| 7527 | case SHOW_LONG: | ||
| 7528 | case SHOW_LONGLONG: | ||
| 7529 | case SHOW_SIGNED_INT: | ||
| 7530 | case SHOW_SIGNED_LONG: | ||
| 7531 | case SHOW_SIGNED_LONGLONG: | ||
| 7532 | case SHOW_HA_ROWS: | ||
| 7533 | case SHOW_BOOL: | ||
| 7534 | case SHOW_MY_BOOL: | ||
| 7535 |
2/2✓ Branch 0 taken 26838 times.
✓ Branch 1 taken 1 times.
|
26839 | if (unsigned_flag) |
| 7536 | 26838 | str->set((ulonglong)val_int(), collation.collation); | |
| 7537 | else | ||
| 7538 | 1 | str->set(val_int(), collation.collation); | |
| 7539 | 26839 | break; | |
| 7540 | ✗ | case SHOW_DOUBLE: | |
| 7541 | ✗ | str->set_real(val_real(), decimals, collation.collation); | |
| 7542 | ✗ | break; | |
| 7543 | |||
| 7544 | ✗ | default: | |
| 7545 | ✗ | my_error(ER_VAR_CANT_BE_READ, MYF(0), var->name.str); | |
| 7546 | ✗ | str = error_str(); | |
| 7547 | ✗ | break; | |
| 7548 | } | ||
| 7549 | 773754 | }; | |
| 7550 |
3/6✓ Branch 0 taken 386867 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 386878 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 386878 times.
|
386876 | if (var_tracker.access_system_variable(thd, f)) { |
| 7551 | ✗ | str = error_str(); | |
| 7552 | } | ||
| 7553 | |||
| 7554 | 386878 | cache_present |= GET_SYS_VAR_CACHE_STRING; | |
| 7555 | 386878 | used_query_id = thd->query_id; | |
| 7556 | 386878 | cached_null_value = null_value; | |
| 7557 | 386878 | return str; | |
| 7558 | 387130 | } | |
| 7559 | |||
| 7560 | 3038 | double Item_func_get_system_var::val_real() { | |
| 7561 |
1/2✓ Branch 0 taken 3038 times.
✗ Branch 1 not taken.
|
3038 | THD *thd = current_thd; |
| 7562 | Audit_global_variable_get_event audit_sys_var(thd, this, | ||
| 7563 |
1/2✓ Branch 0 taken 3038 times.
✗ Branch 1 not taken.
|
3038 | GET_SYS_VAR_CACHE_DOUBLE); |
| 7564 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3038 times.
|
3038 | assert(fixed); |
| 7565 | |||
| 7566 |
3/4✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3032 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
|
3038 | if (cache_present && thd->query_id == used_query_id) { |
| 7567 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | if (cache_present & GET_SYS_VAR_CACHE_DOUBLE) { |
| 7568 | 6 | null_value = cached_null_value; | |
| 7569 | 6 | return cached_dval; | |
| 7570 | ✗ | } else if (cache_present & GET_SYS_VAR_CACHE_LONG) { | |
| 7571 | ✗ | null_value = cached_null_value; | |
| 7572 | ✗ | cached_dval = (double)cached_llval; | |
| 7573 | ✗ | cache_present |= GET_SYS_VAR_CACHE_DOUBLE; | |
| 7574 | ✗ | return cached_dval; | |
| 7575 | ✗ | } else if (cache_present & GET_SYS_VAR_CACHE_STRING) { | |
| 7576 | ✗ | null_value = cached_null_value; | |
| 7577 | ✗ | if (!null_value) | |
| 7578 | ✗ | cached_dval = double_from_string_with_check( | |
| 7579 | ✗ | cached_strval.charset(), cached_strval.c_ptr(), | |
| 7580 | ✗ | cached_strval.c_ptr() + cached_strval.length()); | |
| 7581 | else | ||
| 7582 | ✗ | cached_dval = 0; | |
| 7583 | ✗ | cache_present |= GET_SYS_VAR_CACHE_DOUBLE; | |
| 7584 | ✗ | return cached_dval; | |
| 7585 | } | ||
| 7586 | } | ||
| 7587 | |||
| 7588 | 3032 | auto f = [this, thd](const System_variable_tracker &, | |
| 7589 | 7050 | sys_var *var) -> double { | |
| 7590 |
3/4✓ Branch 0 taken 324 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 2701 times.
✗ Branch 3 not taken.
|
3032 | switch (var->show_type()) { |
| 7591 | 324 | case SHOW_DOUBLE: | |
| 7592 | 324 | mysql_mutex_lock(&LOCK_global_system_variables); | |
| 7593 | 972 | cached_dval = *pointer_cast<const double *>( | |
| 7594 | 324 | var->value_ptr(thd, var_scope, var_tracker.get_keycache_name())); | |
| 7595 | 324 | mysql_mutex_unlock(&LOCK_global_system_variables); | |
| 7596 | 324 | used_query_id = thd->query_id; | |
| 7597 | 324 | cached_null_value = null_value; | |
| 7598 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 324 times.
|
324 | if (null_value) cached_dval = 0; |
| 7599 | 324 | cache_present |= GET_SYS_VAR_CACHE_DOUBLE; | |
| 7600 | 324 | return cached_dval; | |
| 7601 | 7 | case SHOW_CHAR: | |
| 7602 | case SHOW_LEX_STRING: | ||
| 7603 | case SHOW_CHAR_PTR: { | ||
| 7604 | 7 | mysql_mutex_lock(&LOCK_global_system_variables); | |
| 7605 | const char *cptr = | ||
| 7606 | 7 | var->show_type() == SHOW_CHAR | |
| 7607 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
14 | ? pointer_cast<const char *>(var->value_ptr( |
| 7608 | 7 | thd, var_scope, var_tracker.get_keycache_name())) | |
| 7609 | ✗ | : *pointer_cast<const char *const *>(var->value_ptr( | |
| 7610 | ✗ | thd, var_scope, var_tracker.get_keycache_name())); | |
| 7611 | // Treat empty strings as NULL, like val_int() does. | ||
| 7612 |
3/4✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1 times.
|
7 | if (cptr && *cptr) |
| 7613 | 6 | cached_dval = double_from_string_with_check(system_charset_info, cptr, | |
| 7614 | 6 | cptr + strlen(cptr)); | |
| 7615 | else { | ||
| 7616 | 1 | null_value = true; | |
| 7617 | 1 | cached_dval = 0; | |
| 7618 | } | ||
| 7619 | 7 | mysql_mutex_unlock(&LOCK_global_system_variables); | |
| 7620 | 7 | used_query_id = thd->query_id; | |
| 7621 | 7 | cached_null_value = null_value; | |
| 7622 | 7 | cache_present |= GET_SYS_VAR_CACHE_DOUBLE; | |
| 7623 | 7 | return cached_dval; | |
| 7624 | } | ||
| 7625 | 2701 | case SHOW_INT: | |
| 7626 | case SHOW_LONG: | ||
| 7627 | case SHOW_LONGLONG: | ||
| 7628 | case SHOW_SIGNED_INT: | ||
| 7629 | case SHOW_SIGNED_LONG: | ||
| 7630 | case SHOW_SIGNED_LONGLONG: | ||
| 7631 | case SHOW_HA_ROWS: | ||
| 7632 | case SHOW_BOOL: | ||
| 7633 | case SHOW_MY_BOOL: | ||
| 7634 | 2701 | cached_dval = (double)val_int(); | |
| 7635 | 2701 | cache_present |= GET_SYS_VAR_CACHE_DOUBLE; | |
| 7636 | 2701 | used_query_id = thd->query_id; | |
| 7637 | 2701 | cached_null_value = null_value; | |
| 7638 | 2701 | return cached_dval; | |
| 7639 | ✗ | default: | |
| 7640 | ✗ | my_error(ER_VAR_CANT_BE_READ, MYF(0), var->name.str); | |
| 7641 | ✗ | return 0; | |
| 7642 | } | ||
| 7643 | 3032 | }; | |
| 7644 |
1/2✓ Branch 0 taken 3032 times.
✗ Branch 1 not taken.
|
3032 | return var_tracker.access_system_variable<double>(thd, f).value_or(0); |
| 7645 | 3038 | } | |
| 7646 | |||
| 7647 | ✗ | bool Item_func_get_system_var::eq(const Item *item, bool) const { | |
| 7648 | /* Assume we don't have rtti */ | ||
| 7649 | ✗ | if (this == item) return true; // Same item is same. | |
| 7650 | /* Check if other type is also a get_user_var() object */ | ||
| 7651 | ✗ | if (item->type() != FUNC_ITEM || | |
| 7652 | ✗ | down_cast<const Item_func *>(item)->functype() != functype()) | |
| 7653 | ✗ | return false; | |
| 7654 | const Item_func_get_system_var *other = | ||
| 7655 | ✗ | down_cast<const Item_func_get_system_var *>(item); | |
| 7656 | ✗ | return var_tracker == other->var_tracker; | |
| 7657 | } | ||
| 7658 | |||
| 7659 | 624290 | void Item_func_get_system_var::cleanup() { | |
| 7660 | 624290 | Item_func::cleanup(); | |
| 7661 | 624300 | cache_present = 0; | |
| 7662 | 624300 | cached_strval.mem_free(); | |
| 7663 | 624302 | } | |
| 7664 | |||
| 7665 | 2755 | bool Item_func_match::itemize(Parse_context *pc, Item **res) { | |
| 7666 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2755 times.
|
2755 | if (skip_itemize(res)) return false; |
| 7667 |
5/6✓ Branch 0 taken 2751 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2751 times.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 2751 times.
|
2755 | if (super::itemize(pc, res) || against->itemize(pc, &against)) return true; |
| 7668 | 2751 | add_accum_properties(against); | |
| 7669 | |||
| 7670 | 2751 | pc->select->add_ftfunc_to_list(this); | |
| 7671 | 2751 | pc->thd->lex->set_using_match(); | |
| 7672 | |||
| 7673 |
2/2✓ Branch 0 taken 2492 times.
✓ Branch 1 taken 259 times.
|
2751 | switch (pc->select->parsing_place) { |
| 7674 | 2492 | case CTX_WHERE: | |
| 7675 | case CTX_ON: | ||
| 7676 | 2492 | used_in_where_only = true; | |
| 7677 | 2492 | break; | |
| 7678 | 259 | default: | |
| 7679 | 259 | used_in_where_only = false; | |
| 7680 | } | ||
| 7681 | |||
| 7682 | 2751 | return false; | |
| 7683 | } | ||
| 7684 | |||
| 7685 | /** | ||
| 7686 | Initialize searching within full-text index. | ||
| 7687 | |||
| 7688 | @param thd Thread handler | ||
| 7689 | |||
| 7690 | @returns false if success, true if error | ||
| 7691 | */ | ||
| 7692 | |||
| 7693 | 2852 | bool Item_func_match::init_search(THD *thd) { | |
| 7694 |
1/2✓ Branch 0 taken 2852 times.
✗ Branch 1 not taken.
|
2852 | DBUG_TRACE; |
| 7695 | |||
| 7696 | /* | ||
| 7697 | We will skip execution if the item is not fixed | ||
| 7698 | with fix_field | ||
| 7699 | */ | ||
| 7700 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2852 times.
|
2852 | if (!fixed) return false; |
| 7701 | |||
| 7702 | 2852 | TABLE *const table = table_ref->table; | |
| 7703 | /* Check if init_search() has been called before */ | ||
| 7704 |
3/4✓ Branch 0 taken 143 times.
✓ Branch 1 taken 2709 times.
✓ Branch 2 taken 143 times.
✗ Branch 3 not taken.
|
2852 | if (ft_handler && !master) { |
| 7705 | // Update handler::ft_handler even if the search is already initialized. | ||
| 7706 | // If the first call to init_search() was done before we had decided if | ||
| 7707 | // an index scan should be used, and we later decide that we will use | ||
| 7708 | // one, ft_handler is not set. For example, the optimizer calls | ||
| 7709 | // init_search() early if it needs to call Item_func_match::get_count() | ||
| 7710 | // to perform COUNT(*) optimization or decide if a LIMIT clause can be | ||
| 7711 | // satisfied by an index scan. | ||
| 7712 |
2/2✓ Branch 0 taken 110 times.
✓ Branch 1 taken 33 times.
|
143 | if (score_from_index_scan) table->file->ft_handler = ft_handler; |
| 7713 | 143 | return false; | |
| 7714 | } | ||
| 7715 | |||
| 7716 |
2/2✓ Branch 0 taken 26 times.
✓ Branch 1 taken 2683 times.
|
2709 | if (key == NO_SUCH_KEY) { |
| 7717 | 26 | mem_root_deque<Item *> fields(thd->mem_root); | |
| 7718 |
3/6✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 26 times.
✗ Branch 5 not taken.
|
26 | fields.push_back(new Item_string(" ", 1, cmp_collation.collation)); |
| 7719 |
3/4✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 26 times.
|
59 | for (uint i = 0; i < arg_count; i++) fields.push_back(args[i]); |
| 7720 |
2/4✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
|
26 | concat_ws = new Item_func_concat_ws(&fields); |
| 7721 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
|
26 | if (concat_ws == nullptr) return true; |
| 7722 | /* | ||
| 7723 | Above function used only to get value and do not need fix_fields for it: | ||
| 7724 | Item_string - basic constant | ||
| 7725 | fields - fix_fields() was already called for this arguments | ||
| 7726 | Item_func_concat_ws - do not need fix_fields() to produce value | ||
| 7727 | */ | ||
| 7728 | 26 | concat_ws->quick_fix_field(); | |
| 7729 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | } |
| 7730 | |||
| 7731 |
2/2✓ Branch 0 taken 94 times.
✓ Branch 1 taken 2615 times.
|
2709 | if (master) { |
| 7732 |
2/4✓ Branch 0 taken 94 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 94 times.
|
94 | if (master->init_search(thd)) return true; |
| 7733 | |||
| 7734 | 94 | ft_handler = master->ft_handler; | |
| 7735 | 94 | return false; | |
| 7736 | } | ||
| 7737 | |||
| 7738 | 2615 | String *ft_tmp = nullptr; | |
| 7739 | |||
| 7740 | // MATCH ... AGAINST (NULL) is meaningless, but possible | ||
| 7741 |
3/4✓ Branch 0 taken 2615 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2612 times.
|
2615 | if (!(ft_tmp = key_item()->val_str(&value))) { |
| 7742 | 3 | ft_tmp = &value; | |
| 7743 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | value.set("", 0, cmp_collation.collation); |
| 7744 | } | ||
| 7745 | |||
| 7746 |
2/2✓ Branch 0 taken 1334 times.
✓ Branch 1 taken 1281 times.
|
2615 | if (ft_tmp->charset() != cmp_collation.collation) { |
| 7747 | uint dummy_errors; | ||
| 7748 |
1/2✓ Branch 0 taken 1334 times.
✗ Branch 1 not taken.
|
1334 | search_value.copy(ft_tmp->ptr(), ft_tmp->length(), ft_tmp->charset(), |
| 7749 | cmp_collation.collation, &dummy_errors); | ||
| 7750 | 1334 | ft_tmp = &search_value; | |
| 7751 | } | ||
| 7752 | |||
| 7753 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2615 times.
|
2615 | if (!table->is_created()) { |
| 7754 | ✗ | my_error(ER_NO_FT_MATERIALIZED_SUBQUERY, MYF(0)); | |
| 7755 | ✗ | return true; | |
| 7756 | } | ||
| 7757 | |||
| 7758 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2615 times.
|
2615 | assert(master == nullptr); |
| 7759 |
1/2✓ Branch 0 taken 2615 times.
✗ Branch 1 not taken.
|
2615 | ft_handler = table->file->ft_init_ext_with_hints(key, ft_tmp, get_hints()); |
| 7760 |
7/8✓ Branch 0 taken 2608 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 2608 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 2606 times.
✓ Branch 6 taken 9 times.
✓ Branch 7 taken 2606 times.
|
2615 | if (ft_handler == nullptr || thd->is_error()) { |
| 7761 | 9 | return true; | |
| 7762 | } | ||
| 7763 | |||
| 7764 |
2/2✓ Branch 0 taken 2169 times.
✓ Branch 1 taken 437 times.
|
2606 | if (score_from_index_scan) table->file->ft_handler = ft_handler; |
| 7765 | |||
| 7766 | 2606 | return false; | |
| 7767 | 2852 | } | |
| 7768 | |||
| 7769 | 349 | float Item_func_match::get_filtering_effect(THD *, table_map filter_for_table, | |
| 7770 | table_map read_tables, | ||
| 7771 | const MY_BITMAP *fields_to_ignore, | ||
| 7772 | double rows_in_table) { | ||
| 7773 | const Item_field *fld = | ||
| 7774 | 349 | contributes_to_filter(read_tables, filter_for_table, fields_to_ignore); | |
| 7775 |
2/2✓ Branch 0 taken 217 times.
✓ Branch 1 taken 132 times.
|
349 | if (!fld) return COND_FILTER_ALLPASS; |
| 7776 | |||
| 7777 | /* | ||
| 7778 | MATCH () ... AGAINST" is similar to "LIKE '...'" which has the | ||
| 7779 | same selectivity as "col BETWEEN ...". | ||
| 7780 | */ | ||
| 7781 | 132 | return fld->get_cond_filter_default_probability(rows_in_table, | |
| 7782 | 132 | COND_FILTER_BETWEEN); | |
| 7783 | } | ||
| 7784 | |||
| 7785 | /** | ||
| 7786 | Add field into table read set. | ||
| 7787 | |||
| 7788 | @param field field to be added to the table read set. | ||
| 7789 | */ | ||
| 7790 | 3753 | static void update_table_read_set(const Field *field) { | |
| 7791 | 3753 | TABLE *table = field->table; | |
| 7792 | |||
| 7793 |
2/2✓ Branch 0 taken 625 times.
✓ Branch 1 taken 3128 times.
|
3753 | if (!bitmap_test_and_set(table->read_set, field->field_index())) |
| 7794 | 625 | table->covering_keys.intersect(field->part_of_key); | |
| 7795 | 3753 | } | |
| 7796 | |||
| 7797 | 2735 | bool Item_func_match::fix_fields(THD *thd, Item **ref) { | |
| 7798 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2735 times.
|
2735 | assert(fixed == 0); |
| 7799 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2735 times.
|
2735 | assert(arg_count > 0); |
| 7800 | 2735 | Item *item = nullptr; // Safe as arg_count is > 1 | |
| 7801 | |||
| 7802 | 2735 | set_nullable(true); | |
| 7803 | |||
| 7804 | /* | ||
| 7805 | const_item is assumed in quite a bit of places, so it would be difficult | ||
| 7806 | to remove; If it would ever to be removed, this should include | ||
| 7807 | modifications to find_best and auto_close as complement to auto_init code | ||
| 7808 | above. | ||
| 7809 | */ | ||
| 7810 | 2735 | enum_mark_columns save_mark_used_columns = thd->mark_used_columns; | |
| 7811 | /* | ||
| 7812 | Since different engines require different columns for FTS index lookup | ||
| 7813 | we prevent updating of table read_set in argument's ::fix_fields(). | ||
| 7814 | */ | ||
| 7815 | 2735 | thd->mark_used_columns = MARK_COLUMNS_NONE; | |
| 7816 |
4/6✓ Branch 0 taken 2735 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2735 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 2733 times.
|
5470 | if (Item_func::fix_fields(thd, ref) || fix_func_arg(thd, &against) || |
| 7817 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2733 times.
|
2735 | !against->const_for_execution()) { |
| 7818 | 2 | thd->mark_used_columns = save_mark_used_columns; | |
| 7819 | 2 | my_error(ER_WRONG_ARGUMENTS, MYF(0), "AGAINST"); | |
| 7820 | 2 | return true; | |
| 7821 | } | ||
| 7822 | 2733 | thd->mark_used_columns = save_mark_used_columns; | |
| 7823 | |||
| 7824 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2733 times.
|
2733 | if (against->propagate_type(thd)) return true; |
| 7825 | |||
| 7826 | 2733 | bool allows_multi_table_search = true; | |
| 7827 |
2/2✓ Branch 0 taken 4067 times.
✓ Branch 1 taken 2726 times.
|
6793 | for (uint i = 0; i < arg_count; i++) { |
| 7828 | 4067 | item = args[i] = args[i]->real_item(); | |
| 7829 |
4/4✓ Branch 0 taken 4065 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 4060 times.
|
8132 | if (item->type() != Item::FIELD_ITEM || |
| 7830 | /* Cannot use FTS index with outer table field */ | ||
| 7831 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 4060 times.
|
4065 | item->is_outer_reference()) { |
| 7832 | 7 | my_error(ER_WRONG_ARGUMENTS, MYF(0), "MATCH"); | |
| 7833 | 7 | return true; | |
| 7834 | } | ||
| 7835 | 4060 | allows_multi_table_search &= allows_search_on_non_indexed_columns( | |
| 7836 | 4060 | ((Item_field *)item)->field->table); | |
| 7837 | } | ||
| 7838 | |||
| 7839 | /* | ||
| 7840 | Check that all columns come from the same table. | ||
| 7841 | We've already checked that columns in MATCH are fields so | ||
| 7842 | INNER_TABLE_BIT can only appear from AGAINST argument. | ||
| 7843 | */ | ||
| 7844 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2718 times.
|
2726 | if ((used_tables_cache & ~INNER_TABLE_BIT) != item->used_tables()) |
| 7845 | 8 | key = NO_SUCH_KEY; | |
| 7846 | |||
| 7847 |
4/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2718 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 3 times.
|
2726 | if (key == NO_SUCH_KEY && !allows_multi_table_search) { |
| 7848 | 5 | my_error(ER_WRONG_ARGUMENTS, MYF(0), "MATCH"); | |
| 7849 | 5 | return true; | |
| 7850 | } | ||
| 7851 | 2721 | table_ref = ((Item_field *)item)->table_ref; | |
| 7852 | |||
| 7853 |
1/2✓ Branch 0 taken 2721 times.
✗ Branch 1 not taken.
|
2721 | if (table_ref != nullptr) table_ref->set_fulltext_searched(); |
| 7854 | |||
| 7855 | /* | ||
| 7856 | Here we make an assumption that if the engine supports | ||
| 7857 | fulltext extension(HA_CAN_FULLTEXT_EXT flag) then table | ||
| 7858 | can have FTS_DOC_ID column. Atm this is the only way | ||
| 7859 | to distinguish MyISAM and InnoDB engines. | ||
| 7860 | Generally table_ref should be available, but in case of | ||
| 7861 | a generated column's generation expression it's not. Thus | ||
| 7862 | we use field's table, at this moment it's already available. | ||
| 7863 | */ | ||
| 7864 | 2721 | TABLE *const table = | |
| 7865 |
1/2✓ Branch 0 taken 2721 times.
✗ Branch 1 not taken.
|
2721 | table_ref ? table_ref->table : ((Item_field *)item)->field->table; |
| 7866 | |||
| 7867 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 2708 times.
|
2721 | if (!(table->file->ha_table_flags() & HA_CAN_FULLTEXT)) { |
| 7868 | 13 | my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0)); | |
| 7869 | 13 | return true; | |
| 7870 | } | ||
| 7871 | |||
| 7872 |
2/2✓ Branch 0 taken 2373 times.
✓ Branch 1 taken 335 times.
|
2708 | if ((table->file->ha_table_flags() & HA_CAN_FULLTEXT_EXT)) { |
| 7873 | 2373 | Field *doc_id_field = table->fts_doc_id_field; | |
| 7874 | /* | ||
| 7875 | Update read set with FTS_DOC_ID column so that indexes that have | ||
| 7876 | FTS_DOC_ID part can be considered as a covering index. | ||
| 7877 | */ | ||
| 7878 |
2/2✓ Branch 0 taken 337 times.
✓ Branch 1 taken 2036 times.
|
2373 | if (doc_id_field) |
| 7879 | 337 | update_table_read_set(doc_id_field); | |
| 7880 | else { | ||
| 7881 | /* read_set needs to be updated for MATCH arguments */ | ||
| 7882 |
2/2✓ Branch 0 taken 2990 times.
✓ Branch 1 taken 2036 times.
|
5026 | for (uint i = 0; i < arg_count; i++) |
| 7883 | 2990 | update_table_read_set(((Item_field *)args[i])->field); | |
| 7884 | /* | ||
| 7885 | Prevent index only access by non-FTS index if table does not have | ||
| 7886 | FTS_DOC_ID column, find_relevance does not work properly without | ||
| 7887 | FTS_DOC_ID value. Decision for FTS index about index only access | ||
| 7888 | is made later by JOIN::fts_index_access() function. | ||
| 7889 | */ | ||
| 7890 | 2036 | table->covering_keys.clear_all(); | |
| 7891 | } | ||
| 7892 | |||
| 7893 | } else { | ||
| 7894 | /* | ||
| 7895 | Since read_set is not updated for MATCH arguments | ||
| 7896 | it's necessary to update it here for MyISAM. | ||
| 7897 | */ | ||
| 7898 |
2/2✓ Branch 0 taken 426 times.
✓ Branch 1 taken 335 times.
|
761 | for (uint i = 0; i < arg_count; i++) |
| 7899 | 426 | update_table_read_set(((Item_field *)args[i])->field); | |
| 7900 | } | ||
| 7901 | |||
| 7902 |
1/2✓ Branch 0 taken 2708 times.
✗ Branch 1 not taken.
|
2708 | if (!master) { |
| 7903 |
1/2✓ Branch 0 taken 2708 times.
✗ Branch 1 not taken.
|
2708 | Prepared_stmt_arena_holder ps_arena_holder(thd); |
| 7904 |
1/2✓ Branch 0 taken 2708 times.
✗ Branch 1 not taken.
|
2708 | hints = new (thd->mem_root) Ft_hints(flags); |
| 7905 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2708 times.
|
2708 | if (!hints) { |
| 7906 | ✗ | my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0)); | |
| 7907 | ✗ | return true; | |
| 7908 | } | ||
| 7909 |
1/2✓ Branch 0 taken 2708 times.
✗ Branch 1 not taken.
|
2708 | } |
| 7910 | 2708 | return agg_item_collations_for_comparison(cmp_collation, func_name(), args, | |
| 7911 | 2708 | arg_count, 0); | |
| 7912 | } | ||
| 7913 | |||
| 7914 | 2699 | bool Item_func_match::fix_index(const THD *thd) { | |
| 7915 | TABLE *table; | ||
| 7916 | 2699 | uint ft_to_key[MAX_KEY], ft_cnt[MAX_KEY], fts = 0, keynr; | |
| 7917 | 2699 | uint max_cnt = 0, mkeys = 0, i; | |
| 7918 | |||
| 7919 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2699 times.
|
2699 | if (!table_ref) goto err; |
| 7920 | |||
| 7921 | /* | ||
| 7922 | We will skip execution if the item is not fixed | ||
| 7923 | with fix_field | ||
| 7924 | */ | ||
| 7925 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2699 times.
|
2699 | if (!fixed) { |
| 7926 | ✗ | if (allows_search_on_non_indexed_columns(table_ref->table)) | |
| 7927 | ✗ | key = NO_SUCH_KEY; | |
| 7928 | |||
| 7929 | ✗ | return false; | |
| 7930 | } | ||
| 7931 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2696 times.
|
2699 | if (key == NO_SUCH_KEY) return false; |
| 7932 | |||
| 7933 | 2696 | table = table_ref->table; | |
| 7934 |
2/2✓ Branch 0 taken 10144 times.
✓ Branch 1 taken 2696 times.
|
12840 | for (keynr = 0; keynr < table->s->keys; keynr++) { |
| 7935 |
2/2✓ Branch 0 taken 8061 times.
✓ Branch 1 taken 2083 times.
|
18205 | if ((table->key_info[keynr].flags & HA_FULLTEXT) && |
| 7936 |
4/4✓ Branch 0 taken 4509 times.
✓ Branch 1 taken 3552 times.
✓ Branch 2 taken 4497 times.
✓ Branch 3 taken 12 times.
|
8061 | (flags & FT_BOOL ? table->keys_in_use_for_query.is_set(keynr) |
| 7937 |
5/6✓ Branch 0 taken 3552 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3547 times.
✓ Branch 3 taken 5 times.
✓ Branch 4 taken 8044 times.
✓ Branch 5 taken 2100 times.
|
13696 | : table->s->usable_indexes(thd).is_set(keynr))) |
| 7938 | |||
| 7939 | { | ||
| 7940 | 8044 | ft_to_key[fts] = keynr; | |
| 7941 | 8044 | ft_cnt[fts] = 0; | |
| 7942 | 8044 | fts++; | |
| 7943 | } | ||
| 7944 | } | ||
| 7945 | |||
| 7946 |
2/2✓ Branch 0 taken 45 times.
✓ Branch 1 taken 2651 times.
|
2696 | if (!fts) goto err; |
| 7947 | |||
| 7948 |
2/2✓ Branch 0 taken 3961 times.
✓ Branch 1 taken 2651 times.
|
6612 | for (i = 0; i < arg_count; i++) { |
| 7949 | Item_field *item = | ||
| 7950 |
2/4✓ Branch 0 taken 3961 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3961 times.
✗ Branch 3 not taken.
|
3961 | down_cast<Item_field *>(unwrap_rollup_group(args[i])->real_item()); |
| 7951 |
2/2✓ Branch 0 taken 10851 times.
✓ Branch 1 taken 3961 times.
|
14812 | for (keynr = 0; keynr < fts; keynr++) { |
| 7952 | 10851 | KEY *ft_key = &table->key_info[ft_to_key[keynr]]; | |
| 7953 | 10851 | uint key_parts = ft_key->user_defined_key_parts; | |
| 7954 | |||
| 7955 |
2/2✓ Branch 0 taken 14696 times.
✓ Branch 1 taken 10851 times.
|
25547 | for (uint part = 0; part < key_parts; part++) { |
| 7956 |
3/4✓ Branch 0 taken 14696 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4726 times.
✓ Branch 3 taken 9970 times.
|
14696 | if (item->field->eq(ft_key->key_part[part].field)) ft_cnt[keynr]++; |
| 7957 | } | ||
| 7958 | } | ||
| 7959 | } | ||
| 7960 | |||
| 7961 |
2/2✓ Branch 0 taken 8044 times.
✓ Branch 1 taken 2651 times.
|
10695 | for (keynr = 0; keynr < fts; keynr++) { |
| 7962 |
2/2✓ Branch 0 taken 2774 times.
✓ Branch 1 taken 5270 times.
|
8044 | if (ft_cnt[keynr] > max_cnt) { |
| 7963 | 2774 | mkeys = 0; | |
| 7964 | 2774 | max_cnt = ft_cnt[mkeys] = ft_cnt[keynr]; | |
| 7965 | 2774 | ft_to_key[mkeys] = ft_to_key[keynr]; | |
| 7966 | 2774 | continue; | |
| 7967 | } | ||
| 7968 |
4/4✓ Branch 0 taken 3073 times.
✓ Branch 1 taken 2197 times.
✓ Branch 2 taken 400 times.
✓ Branch 3 taken 2673 times.
|
5270 | if (max_cnt && ft_cnt[keynr] == max_cnt) { |
| 7969 | 400 | mkeys++; | |
| 7970 | 400 | ft_cnt[mkeys] = ft_cnt[keynr]; | |
| 7971 | 400 | ft_to_key[mkeys] = ft_to_key[keynr]; | |
| 7972 | 400 | continue; | |
| 7973 | } | ||
| 7974 | } | ||
| 7975 | |||
| 7976 |
2/2✓ Branch 0 taken 2707 times.
✓ Branch 1 taken 12 times.
|
2719 | for (keynr = 0; keynr <= mkeys; keynr++) { |
| 7977 | // partial keys doesn't work | ||
| 7978 |
2/2✓ Branch 0 taken 2697 times.
✓ Branch 1 taken 10 times.
|
2707 | if (max_cnt < arg_count || |
| 7979 |
2/2✓ Branch 0 taken 58 times.
✓ Branch 1 taken 2639 times.
|
2697 | max_cnt < table->key_info[ft_to_key[keynr]].user_defined_key_parts) |
| 7980 | 68 | continue; | |
| 7981 | |||
| 7982 | 2639 | key = ft_to_key[keynr]; | |
| 7983 | |||
| 7984 | 2639 | return false; | |
| 7985 | } | ||
| 7986 | |||
| 7987 | 12 | err: | |
| 7988 |
5/6✓ Branch 0 taken 57 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
✓ Branch 3 taken 34 times.
✓ Branch 4 taken 23 times.
✓ Branch 5 taken 34 times.
|
114 | if (table_ref != nullptr && |
| 7989 | 57 | allows_search_on_non_indexed_columns(table_ref->table)) { | |
| 7990 | 23 | key = NO_SUCH_KEY; | |
| 7991 | 23 | return false; | |
| 7992 | } | ||
| 7993 |
1/2✓ Branch 0 taken 34 times.
✗ Branch 1 not taken.
|
34 | my_error(ER_FT_MATCHING_KEY_NOT_FOUND, MYF(0)); |
| 7994 | 34 | return true; | |
| 7995 | } | ||
| 7996 | |||
| 7997 | 658 | bool Item_func_match::eq(const Item *item, bool binary_cmp) const { | |
| 7998 | /* We ignore FT_SORTED flag when checking for equality since result is | ||
| 7999 | equivalent regardless of sorting */ | ||
| 8000 |
4/4✓ Branch 0 taken 327 times.
✓ Branch 1 taken 331 times.
✓ Branch 2 taken 358 times.
✓ Branch 3 taken 300 times.
|
985 | if (!is_function_of_type(item, FT_FUNC) || |
| 8001 | 327 | (flags | FT_SORTED) != | |
| 8002 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 300 times.
|
327 | (down_cast<const Item_func_match *>(item)->flags | FT_SORTED)) |
| 8003 | 358 | return false; | |
| 8004 | |||
| 8005 | 300 | const Item_func_match *ifm = down_cast<const Item_func_match *>(item); | |
| 8006 | |||
| 8007 |
6/6✓ Branch 0 taken 293 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 270 times.
✓ Branch 3 taken 23 times.
✓ Branch 4 taken 236 times.
✓ Branch 5 taken 64 times.
|
570 | if (key == ifm->key && table_ref == ifm->table_ref && |
| 8008 |
2/2✓ Branch 0 taken 236 times.
✓ Branch 1 taken 34 times.
|
270 | key_item()->eq(ifm->key_item(), binary_cmp)) |
| 8009 | 236 | return true; | |
| 8010 | |||
| 8011 | 64 | return false; | |
| 8012 | } | ||
| 8013 | |||
| 8014 | 62678 | double Item_func_match::val_real() { | |
| 8015 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62678 times.
|
62678 | assert(fixed); |
| 8016 | |||
| 8017 | // MATCH only knows how to get the score for base columns. Other types of | ||
| 8018 | // expressions (such as function calls or rollup columns) should have been | ||
| 8019 | // rejected during resolving. | ||
| 8020 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62678 times.
|
62678 | assert(!has_rollup_expr()); |
| 8021 |
2/4✓ Branch 0 taken 62678 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 62678 times.
|
129457 | assert(std::all_of(args, args + arg_count, [](const Item *item) { |
| 8022 | return item->real_item()->type() == FIELD_ITEM; | ||
| 8023 | })); | ||
| 8024 | |||
| 8025 |
1/2✓ Branch 0 taken 62678 times.
✗ Branch 1 not taken.
|
62678 | DBUG_TRACE; |
| 8026 |
2/2✓ Branch 0 taken 2222 times.
✓ Branch 1 taken 60456 times.
|
62678 | if (ft_handler == nullptr) return -1.0; |
| 8027 | |||
| 8028 | 60456 | TABLE *const table = table_ref->table; | |
| 8029 |
6/6✓ Branch 0 taken 60408 times.
✓ Branch 1 taken 48 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 60403 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 60451 times.
|
60456 | if (key != NO_SUCH_KEY && table->has_null_row()) // NULL row from outer join |
| 8030 | 5 | return 0.0; | |
| 8031 | |||
| 8032 |
3/4✓ Branch 0 taken 60451 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50435 times.
✓ Branch 3 taken 10016 times.
|
60451 | if (get_master()->score_from_index_scan) { |
| 8033 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 50435 times.
|
50435 | assert(table->file->ft_handler == ft_handler); |
| 8034 |
1/2✓ Branch 0 taken 50435 times.
✗ Branch 1 not taken.
|
50435 | return ft_handler->please->get_relevance(ft_handler); |
| 8035 | } | ||
| 8036 | |||
| 8037 |
2/2✓ Branch 0 taken 48 times.
✓ Branch 1 taken 9968 times.
|
10016 | if (key == NO_SUCH_KEY) { |
| 8038 |
1/2✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
|
48 | String *a = concat_ws->val_str(&value); |
| 8039 |
5/6✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 47 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 47 times.
|
48 | if ((null_value = (a == nullptr)) || !a->length()) return 0; |
| 8040 |
1/2✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
|
47 | return ft_handler->please->find_relevance(ft_handler, (uchar *)a->ptr(), |
| 8041 | 94 | a->length()); | |
| 8042 | } | ||
| 8043 |
1/2✓ Branch 0 taken 9968 times.
✗ Branch 1 not taken.
|
9968 | return ft_handler->please->find_relevance(ft_handler, table->record[0], 0); |
| 8044 | 62678 | } | |
| 8045 | |||
| 8046 | 304 | void Item_func_match::print(const THD *thd, String *str, | |
| 8047 | enum_query_type query_type) const { | ||
| 8048 | 304 | str->append(STRING_WITH_LEN("(match ")); | |
| 8049 | 304 | print_args(thd, str, 0, query_type); | |
| 8050 | 304 | str->append(STRING_WITH_LEN(" against (")); | |
| 8051 | 304 | against->print(thd, str, query_type); | |
| 8052 |
2/2✓ Branch 0 taken 89 times.
✓ Branch 1 taken 215 times.
|
304 | if (flags & FT_BOOL) |
| 8053 | 89 | str->append(STRING_WITH_LEN(" in boolean mode")); | |
| 8054 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 203 times.
|
215 | else if (flags & FT_EXPAND) |
| 8055 | 12 | str->append(STRING_WITH_LEN(" with query expansion")); | |
| 8056 | 304 | str->append(STRING_WITH_LEN("))")); | |
| 8057 | 304 | } | |
| 8058 | |||
| 8059 | /** | ||
| 8060 | Function sets FT hints(LIMIT, flags) depending on | ||
| 8061 | various join conditions. | ||
| 8062 | |||
| 8063 | @param join Pointer to JOIN object. | ||
| 8064 | @param ft_flag FT flag value. | ||
| 8065 | @param ft_limit Limit value. | ||
| 8066 | @param no_cond true if MATCH is not used in WHERE condition. | ||
| 8067 | */ | ||
| 8068 | |||
| 8069 | 2390 | void Item_func_match::set_hints(JOIN *join, uint ft_flag, ha_rows ft_limit, | |
| 8070 | bool no_cond) { | ||
| 8071 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2390 times.
|
2390 | assert(!master); |
| 8072 | |||
| 8073 |
2/2✓ Branch 0 taken 143 times.
✓ Branch 1 taken 2247 times.
|
2390 | if (!join) // used for count() optimization |
| 8074 | { | ||
| 8075 | 143 | hints->set_hint_flag(ft_flag); | |
| 8076 | 143 | return; | |
| 8077 | } | ||
| 8078 | |||
| 8079 | /* skip hints setting if there are aggregates(except of FT_NO_RANKING) */ | ||
| 8080 |
6/6✓ Branch 0 taken 2031 times.
✓ Branch 1 taken 216 times.
✓ Branch 2 taken 2024 times.
✓ Branch 3 taken 7 times.
✓ Branch 4 taken 229 times.
✓ Branch 5 taken 2018 times.
|
4271 | if (join->implicit_grouping || !join->group_list.empty() || |
| 8081 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2018 times.
|
2024 | join->select_distinct) { |
| 8082 | /* 'No ranking' is possible even if aggregates are present */ | ||
| 8083 |
2/2✓ Branch 0 taken 140 times.
✓ Branch 1 taken 89 times.
|
229 | if ((ft_flag & FT_NO_RANKING)) hints->set_hint_flag(FT_NO_RANKING); |
| 8084 | 229 | return; | |
| 8085 | } | ||
| 8086 | |||
| 8087 | 2018 | hints->set_hint_flag(ft_flag); | |
| 8088 | |||
| 8089 | /** | ||
| 8090 | Only one table is used, there is no aggregates, | ||
| 8091 | WHERE condition is a single MATCH expression | ||
| 8092 | (WHERE MATCH(..) or WHERE MATCH(..) [>=,>] value) or | ||
| 8093 | there is no WHERE condition. | ||
| 8094 | */ | ||
| 8095 |
8/8✓ Branch 0 taken 1996 times.
✓ Branch 1 taken 22 times.
✓ Branch 2 taken 1986 times.
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 1944 times.
✓ Branch 5 taken 42 times.
✓ Branch 6 taken 1954 times.
✓ Branch 7 taken 64 times.
|
2018 | if (join->primary_tables == 1 && (no_cond || is_simple_expression())) |
| 8096 | 1954 | hints->set_hint_limit(ft_limit); | |
| 8097 | } | ||
| 8098 | |||
| 8099 | /*************************************************************************** | ||
| 8100 | System variables | ||
| 8101 | ****************************************************************************/ | ||
| 8102 | |||
| 8103 | /** | ||
| 8104 | Return value of an system variable base[.name] as a constant item. | ||
| 8105 | |||
| 8106 | @param pc Current parse context | ||
| 8107 | @param scope Global / session | ||
| 8108 | @param prefix Optional prefix part of the variable name | ||
| 8109 | @param suffix Trivial name of suffix part of the variable name | ||
| 8110 | @param unsafe_for_replication If true and if the variable is written to a | ||
| 8111 | binlog then mark the statement as unsafe. | ||
| 8112 | |||
| 8113 | @note | ||
| 8114 | If component.str = 0 then the variable name is in 'name' | ||
| 8115 | |||
| 8116 | @return | ||
| 8117 | - 0 : error | ||
| 8118 | - # : constant item | ||
| 8119 | */ | ||
| 8120 | |||
| 8121 | 582762 | Item *get_system_variable(Parse_context *pc, enum_var_type scope, | |
| 8122 | const LEX_CSTRING &prefix, const LEX_CSTRING &suffix, | ||
| 8123 | bool unsafe_for_replication) { | ||
| 8124 | 582762 | THD *thd = pc->thd; | |
| 8125 | |||
| 8126 | enum_var_type resolved_scope; | ||
| 8127 | 582762 | bool written_to_binlog_flag = false; | |
| 8128 | 582634 | auto f = [thd, scope, &resolved_scope, &written_to_binlog_flag]( | |
| 8129 | 2631256 | const System_variable_tracker &, sys_var *v) -> bool { | |
| 8130 |
2/2✓ Branch 0 taken 280526 times.
✓ Branch 1 taken 302108 times.
|
582634 | if (scope == OPT_DEFAULT) { |
| 8131 |
2/2✓ Branch 0 taken 72846 times.
✓ Branch 1 taken 207681 times.
|
280526 | if (v->check_scope(OPT_SESSION)) { |
| 8132 | 72846 | resolved_scope = OPT_SESSION; | |
| 8133 | } else { | ||
| 8134 | /* As there was no local variable, return the global value */ | ||
| 8135 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 207680 times.
|
207681 | assert(v->check_scope(OPT_GLOBAL)); |
| 8136 | 207680 | resolved_scope = OPT_GLOBAL; | |
| 8137 | } | ||
| 8138 |
2/2✓ Branch 0 taken 301414 times.
✓ Branch 1 taken 694 times.
|
302108 | } else if (v->check_scope(scope)) { |
| 8139 | 301414 | resolved_scope = scope; | |
| 8140 | } else { | ||
| 8141 |
2/2✓ Branch 0 taken 28 times.
✓ Branch 1 taken 666 times.
|
694 | my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0), v->name.str, |
| 8142 | scope == OPT_GLOBAL ? "SESSION" : "GLOBAL"); | ||
| 8143 | 694 | return true; | |
| 8144 | } | ||
| 8145 | |||
| 8146 | 581940 | written_to_binlog_flag = v->is_written_to_binlog(resolved_scope); | |
| 8147 | 581940 | v->do_deprecated_warning(thd); | |
| 8148 | 581938 | return false; | |
| 8149 | 582762 | }; | |
| 8150 | System_variable_tracker var_tracker = System_variable_tracker::make_tracker( | ||
| 8151 |
1/2✓ Branch 0 taken 582760 times.
✗ Branch 1 not taken.
|
582762 | to_string_view(prefix), to_string_view(suffix)); |
| 8152 |
4/6✓ Branch 0 taken 582759 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 582761 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 822 times.
✓ Branch 5 taken 581940 times.
|
582760 | if (var_tracker.access_system_variable<bool>(thd, f).value_or(true)) { |
| 8153 | 822 | return nullptr; | |
| 8154 | } | ||
| 8155 | |||
| 8156 |
4/4✓ Branch 0 taken 575863 times.
✓ Branch 1 taken 6077 times.
✓ Branch 2 taken 564034 times.
✓ Branch 3 taken 11829 times.
|
581940 | if (unsafe_for_replication && !written_to_binlog_flag) |
| 8157 |
1/2✓ Branch 0 taken 564035 times.
✗ Branch 1 not taken.
|
564034 | thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_VARIABLE); |
| 8158 | |||
| 8159 | 581941 | thd->lex->set_uncacheable(pc->select, UNCACHEABLE_SIDEEFFECT); | |
| 8160 | |||
| 8161 |
2/4✓ Branch 0 taken 581941 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 581941 times.
✗ Branch 3 not taken.
|
581941 | return new Item_func_get_system_var(var_tracker, resolved_scope); |
| 8162 | 582763 | } | |
| 8163 | |||
| 8164 | 4578 | bool Item_func_row_count::itemize(Parse_context *pc, Item **res) { | |
| 8165 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4578 times.
|
4578 | if (skip_itemize(res)) return false; |
| 8166 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4578 times.
|
4578 | if (super::itemize(pc, res)) return true; |
| 8167 | |||
| 8168 | 4578 | LEX *lex = pc->thd->lex; | |
| 8169 | 4578 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 8170 | 4578 | lex->safe_to_cache_query = false; | |
| 8171 | 4578 | return false; | |
| 8172 | } | ||
| 8173 | |||
| 8174 | 400 | longlong Item_func_row_count::val_int() { | |
| 8175 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 400 times.
|
400 | assert(fixed == 1); |
| 8176 | 400 | THD *thd = current_thd; | |
| 8177 | |||
| 8178 | 400 | return thd->get_row_count_func(); | |
| 8179 | } | ||
| 8180 | |||
| 8181 | 177368 | Item_func_sp::Item_func_sp(const POS &pos, const LEX_STRING &db_name, | |
| 8182 | const LEX_STRING &fn_name, bool use_explicit_name, | ||
| 8183 | 177368 | PT_item_list *opt_list) | |
| 8184 | 177368 | : Item_func(pos, opt_list) { | |
| 8185 | /* | ||
| 8186 | Set to false here, which is the default according to SQL standard. | ||
| 8187 | RETURNS NULL ON NULL INPUT can be implemented by modifying this member. | ||
| 8188 | */ | ||
| 8189 | 177368 | null_on_null = false; | |
| 8190 | 177368 | set_nullable(true); | |
| 8191 | 177368 | set_stored_program(); | |
| 8192 |
1/2✓ Branch 0 taken 177368 times.
✗ Branch 1 not taken.
|
177368 | THD *thd = current_thd; |
| 8193 | 177368 | m_name = new (thd->mem_root) | |
| 8194 |
1/2✓ Branch 0 taken 177368 times.
✗ Branch 1 not taken.
|
177368 | sp_name(to_lex_cstring(db_name), fn_name, use_explicit_name); |
| 8195 | 177368 | } | |
| 8196 | |||
| 8197 | 177368 | bool Item_func_sp::itemize(Parse_context *pc, Item **res) { | |
| 8198 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 177368 times.
|
177368 | if (skip_itemize(res)) return false; |
| 8199 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 177366 times.
|
177368 | if (super::itemize(pc, res)) return true; |
| 8200 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 177366 times.
|
177366 | if (m_name == nullptr) return true; // OOM |
| 8201 | |||
| 8202 | 177366 | THD *thd = pc->thd; | |
| 8203 | 177366 | LEX *lex = thd->lex; | |
| 8204 | |||
| 8205 | 177366 | context = lex->current_context(); | |
| 8206 | 177366 | lex->safe_to_cache_query = false; | |
| 8207 | |||
| 8208 |
2/2✓ Branch 0 taken 71016 times.
✓ Branch 1 taken 106350 times.
|
177366 | if (m_name->m_db.str == nullptr) { |
| 8209 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 71014 times.
|
71016 | if (thd->lex->copy_db_to(&m_name->m_db.str, &m_name->m_db.length)) { |
| 8210 | 2 | my_error(ER_NO_DB_ERROR, MYF(0)); | |
| 8211 | 2 | return true; | |
| 8212 | } | ||
| 8213 | } | ||
| 8214 | |||
| 8215 | 177364 | m_name->init_qname(thd); | |
| 8216 |
2/4✓ Branch 0 taken 177364 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 177364 times.
✗ Branch 3 not taken.
|
177364 | sp_add_own_used_routine(lex, thd, Sroutine_hash_entry::FUNCTION, m_name); |
| 8217 | |||
| 8218 | 177364 | return false; | |
| 8219 | } | ||
| 8220 | |||
| 8221 | 236098 | void Item_func_sp::cleanup() { | |
| 8222 |
2/2✓ Branch 0 taken 216273 times.
✓ Branch 1 taken 19825 times.
|
236098 | if (sp_result_field != nullptr) { |
| 8223 | 216273 | sp_result_field->mem_free(); | |
| 8224 | 216273 | sp_result_field->table->in_use = nullptr; | |
| 8225 | } | ||
| 8226 | 236098 | m_sp = nullptr; | |
| 8227 | 236098 | Item_func::cleanup(); | |
| 8228 | 236098 | } | |
| 8229 | |||
| 8230 | 74286 | const char *Item_func_sp::func_name() const { | |
| 8231 |
1/2✓ Branch 0 taken 74286 times.
✗ Branch 1 not taken.
|
74286 | const THD *thd = current_thd; |
| 8232 | /* Calculate length to avoid reallocation of string for sure */ | ||
| 8233 | 74286 | size_t len = | |
| 8234 |
2/2✓ Branch 0 taken 71321 times.
✓ Branch 1 taken 2965 times.
|
74286 | (((m_name->m_explicit_name ? m_name->m_db.length : 0) + |
| 8235 | 74286 | m_name->m_name.length) * | |
| 8236 | 74286 | 2 + // characters*quoting | |
| 8237 | 74286 | 2 + // ` and ` | |
| 8238 |
2/2✓ Branch 0 taken 71321 times.
✓ Branch 1 taken 2965 times.
|
74286 | (m_name->m_explicit_name ? 3 : 0) + // '`', '`' and '.' for the db |
| 8239 | 1 + // end of string | ||
| 8240 | ALIGN_SIZE(1)); // to avoid String reallocation | ||
| 8241 |
1/2✓ Branch 0 taken 74286 times.
✗ Branch 1 not taken.
|
74286 | String qname((char *)thd->mem_root->Alloc(len), len, system_charset_info); |
| 8242 | |||
| 8243 | 74286 | qname.length(0); | |
| 8244 |
2/2✓ Branch 0 taken 71321 times.
✓ Branch 1 taken 2965 times.
|
74286 | if (m_name->m_explicit_name) { |
| 8245 |
1/2✓ Branch 0 taken 71321 times.
✗ Branch 1 not taken.
|
71321 | append_identifier(thd, &qname, m_name->m_db.str, m_name->m_db.length); |
| 8246 |
1/2✓ Branch 0 taken 71321 times.
✗ Branch 1 not taken.
|
71321 | qname.append('.'); |
| 8247 | } | ||
| 8248 |
1/2✓ Branch 0 taken 74286 times.
✗ Branch 1 not taken.
|
74286 | append_identifier(thd, &qname, m_name->m_name.str, m_name->m_name.length); |
| 8249 | 148572 | return qname.ptr(); | |
| 8250 | 74286 | } | |
| 8251 | |||
| 8252 | 124214 | table_map Item_func_sp::get_initial_pseudo_tables() const { | |
| 8253 | /* | ||
| 8254 | INNER_TABLE_BIT prevents function from being evaluated in preparation phase. | ||
| 8255 | @todo - make this dependent on READS SQL or MODIFIES SQL. | ||
| 8256 | Due to bug#26422182, a function cannot be executed before tables | ||
| 8257 | are locked, even though it accesses no tables. | ||
| 8258 | */ | ||
| 8259 |
2/2✓ Branch 0 taken 96038 times.
✓ Branch 1 taken 28176 times.
|
124214 | return m_deterministic ? INNER_TABLE_BIT : RAND_TABLE_BIT; |
| 8260 | } | ||
| 8261 | |||
| 8262 | 88 | static void my_missing_function_error(const LEX_STRING &token, | |
| 8263 | const char *func_name) { | ||
| 8264 |
5/6✓ Branch 0 taken 88 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 87 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 87 times.
|
88 | if (token.length && is_lex_native_function(&token)) |
| 8265 | 1 | my_error(ER_FUNC_INEXISTENT_NAME_COLLISION, MYF(0), func_name); | |
| 8266 | else | ||
| 8267 | 87 | my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "FUNCTION", func_name); | |
| 8268 | 88 | } | |
| 8269 | |||
| 8270 | /** | ||
| 8271 | @brief Initialize the result field by creating a temporary dummy table | ||
| 8272 | and assign it to a newly created field object. Meta data used to | ||
| 8273 | create the field is fetched from the sp_head belonging to the stored | ||
| 8274 | procedure found in the stored procedure function cache. | ||
| 8275 | |||
| 8276 | @note This function should be called from fix_fields to init the result | ||
| 8277 | field. It is some what related to Item_field. | ||
| 8278 | |||
| 8279 | @see Item_field | ||
| 8280 | |||
| 8281 | @param thd A pointer to the session and thread context. | ||
| 8282 | |||
| 8283 | @return Function return error status. | ||
| 8284 | @retval true is returned on an error | ||
| 8285 | @retval false is returned on success. | ||
| 8286 | */ | ||
| 8287 | |||
| 8288 | 114273 | bool Item_func_sp::init_result_field(THD *thd) { | |
| 8289 | 114273 | LEX_CSTRING empty_name = {STRING_WITH_LEN("")}; | |
| 8290 |
1/2✓ Branch 0 taken 114273 times.
✗ Branch 1 not taken.
|
114273 | DBUG_TRACE; |
| 8291 | |||
| 8292 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 114273 times.
|
114273 | assert(m_sp == nullptr); |
| 8293 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 114273 times.
|
114273 | assert(sp_result_field == nullptr); |
| 8294 | |||
| 8295 | Internal_error_handler_holder<View_error_handler, TABLE_LIST> view_handler( | ||
| 8296 |
1/2✓ Branch 0 taken 114273 times.
✗ Branch 1 not taken.
|
114273 | thd, context->view_error_handler, context->view_error_handler_arg); |
| 8297 |
1/2✓ Branch 0 taken 114273 times.
✗ Branch 1 not taken.
|
114273 | m_sp = sp_find_routine(thd, enum_sp_type::FUNCTION, m_name, |
| 8298 | &thd->sp_func_cache, true); | ||
| 8299 |
2/2✓ Branch 0 taken 88 times.
✓ Branch 1 taken 114185 times.
|
114273 | if (m_sp == nullptr) { |
| 8300 |
1/2✓ Branch 0 taken 88 times.
✗ Branch 1 not taken.
|
88 | my_missing_function_error(m_name->m_name, m_name->m_qname.str); |
| 8301 | 88 | return true; | |
| 8302 | } | ||
| 8303 | |||
| 8304 | 114185 | m_deterministic = m_sp->m_chistics->detistic; | |
| 8305 | |||
| 8306 | /* | ||
| 8307 | A Field need to be attached to a Table. | ||
| 8308 | Below we "create" a dummy table by initializing | ||
| 8309 | the needed pointers. | ||
| 8310 | */ | ||
| 8311 |
2/4✓ Branch 0 taken 114185 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 114185 times.
✗ Branch 3 not taken.
|
114185 | TABLE *dummy_table = new (thd->mem_root) TABLE; |
| 8312 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 114185 times.
|
114185 | if (dummy_table == nullptr) return true; |
| 8313 |
2/4✓ Branch 0 taken 114185 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 114185 times.
✗ Branch 3 not taken.
|
114185 | TABLE_SHARE *share = new (thd->mem_root) TABLE_SHARE; |
| 8314 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 114185 times.
|
114185 | if (share == nullptr) return true; |
| 8315 | |||
| 8316 | 114185 | dummy_table->s = share; | |
| 8317 | 114185 | dummy_table->alias = ""; | |
| 8318 |
1/2✓ Branch 0 taken 114185 times.
✗ Branch 1 not taken.
|
114185 | if (is_nullable()) dummy_table->set_nullable(); |
| 8319 | 114185 | dummy_table->in_use = thd; | |
| 8320 | 114185 | dummy_table->copy_blobs = true; | |
| 8321 | 114185 | share->table_cache_key = empty_name; | |
| 8322 | 114185 | share->db = empty_name; | |
| 8323 | 114185 | share->table_name = empty_name; | |
| 8324 | |||
| 8325 | 114185 | sp_result_field = | |
| 8326 |
1/2✓ Branch 0 taken 114185 times.
✗ Branch 1 not taken.
|
114185 | m_sp->create_result_field(thd, max_length, item_name.ptr(), dummy_table); |
| 8327 | 114185 | return sp_result_field == nullptr; | |
| 8328 | 114273 | } | |
| 8329 | |||
| 8330 | /** | ||
| 8331 | @brief Initialize local members with values from the Field interface. | ||
| 8332 | |||
| 8333 | @note called from Item::fix_fields. | ||
| 8334 | */ | ||
| 8335 | |||
| 8336 | 114180 | bool Item_func_sp::resolve_type(THD *) { | |
| 8337 |
1/2✓ Branch 0 taken 114180 times.
✗ Branch 1 not taken.
|
114180 | DBUG_TRACE; |
| 8338 | |||
| 8339 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 114180 times.
|
114180 | assert(sp_result_field); |
| 8340 |
1/2✓ Branch 0 taken 114180 times.
✗ Branch 1 not taken.
|
114180 | set_data_type(sp_result_field->type()); |
| 8341 |
1/2✓ Branch 0 taken 114180 times.
✗ Branch 1 not taken.
|
114180 | decimals = sp_result_field->decimals(); |
| 8342 | 114180 | max_length = sp_result_field->field_length; | |
| 8343 |
1/2✓ Branch 0 taken 114180 times.
✗ Branch 1 not taken.
|
114180 | collation.set(sp_result_field->charset()); |
| 8344 | 114180 | set_nullable(true); | |
| 8345 | 114180 | unsigned_flag = sp_result_field->is_flag_set(UNSIGNED_FLAG); | |
| 8346 | |||
| 8347 | 114180 | return false; | |
| 8348 | 114180 | } | |
| 8349 | |||
| 8350 | 236948 | longlong Item_func_sp::val_int() { | |
| 8351 |
2/2✓ Branch 0 taken 238 times.
✓ Branch 1 taken 236710 times.
|
236948 | if (execute()) return error_int(); |
| 8352 |
2/2✓ Branch 0 taken 24761 times.
✓ Branch 1 taken 211949 times.
|
236710 | if (null_value) return 0; |
| 8353 | 211949 | return sp_result_field->val_int(); | |
| 8354 | } | ||
| 8355 | |||
| 8356 | 156 | double Item_func_sp::val_real() { | |
| 8357 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 152 times.
|
156 | if (execute()) return error_real(); |
| 8358 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 151 times.
|
152 | if (null_value) return 0.0; |
| 8359 | 151 | return sp_result_field->val_real(); | |
| 8360 | } | ||
| 8361 | |||
| 8362 | 13 | bool Item_func_sp::get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) { | |
| 8363 |
5/6✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 12 times.
|
13 | if (execute() || null_value) return true; |
| 8364 | 12 | return sp_result_field->get_date(ltime, fuzzydate); | |
| 8365 | } | ||
| 8366 | |||
| 8367 | 7 | bool Item_func_sp::get_time(MYSQL_TIME *ltime) { | |
| 8368 |
3/6✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 7 times.
|
7 | if (execute() || null_value) return true; |
| 8369 | 7 | return sp_result_field->get_time(ltime); | |
| 8370 | } | ||
| 8371 | |||
| 8372 | 1232 | my_decimal *Item_func_sp::val_decimal(my_decimal *dec_buf) { | |
| 8373 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1231 times.
|
1232 | if (execute()) return error_decimal(dec_buf); |
| 8374 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1231 times.
|
1231 | if (null_value) return nullptr; |
| 8375 | 1231 | return sp_result_field->val_decimal(dec_buf); | |
| 8376 | } | ||
| 8377 | |||
| 8378 | 165965 | String *Item_func_sp::val_str(String *str) { | |
| 8379 | 165965 | StringBuffer<STRING_BUFFER_USUAL_SIZE> buf(str->charset()); | |
| 8380 |
4/6✓ Branch 0 taken 165965 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 165947 times.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
|
165965 | if (execute()) return error_str(); |
| 8381 |
2/2✓ Branch 0 taken 124 times.
✓ Branch 1 taken 165823 times.
|
165947 | if (null_value) return nullptr; |
| 8382 | /* | ||
| 8383 | result_field will set buf pointing to internal buffer | ||
| 8384 | of the resul_field. Due to this it will change any time | ||
| 8385 | when SP is executed. In order to prevent occasional | ||
| 8386 | corruption of returned value, we make here a copy. | ||
| 8387 | */ | ||
| 8388 |
1/2✓ Branch 0 taken 165823 times.
✗ Branch 1 not taken.
|
165823 | sp_result_field->val_str(&buf); |
| 8389 |
1/2✓ Branch 0 taken 165823 times.
✗ Branch 1 not taken.
|
165823 | str->copy(buf); |
| 8390 | 165823 | return str; | |
| 8391 | 165965 | } | |
| 8392 | |||
| 8393 | 6 | bool Item_func_sp::val_json(Json_wrapper *result) { | |
| 8394 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | if (sp_result_field->type() == MYSQL_TYPE_JSON) { |
| 8395 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5 times.
|
6 | if (execute()) return true; |
| 8396 | |||
| 8397 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if (null_value) return false; |
| 8398 | |||
| 8399 | 5 | Field_json *json_value = down_cast<Field_json *>(sp_result_field); | |
| 8400 | 5 | return json_value->val_json(result); | |
| 8401 | } | ||
| 8402 | |||
| 8403 | /* purecov: begin deadcode */ | ||
| 8404 | ✗ | assert(false); | |
| 8405 | my_error(ER_INVALID_CAST_TO_JSON, MYF(0)); | ||
| 8406 | return error_json(); | ||
| 8407 | /* purecov: end */ | ||
| 8408 | } | ||
| 8409 | |||
| 8410 | /** | ||
| 8411 | @brief Execute function & store value in field. | ||
| 8412 | Will set null_value properly only for a successful execution. | ||
| 8413 | @return Function returns error status. | ||
| 8414 | @retval false on success. | ||
| 8415 | @retval true if an error occurred. | ||
| 8416 | */ | ||
| 8417 | |||
| 8418 | 404327 | bool Item_func_sp::execute() { | |
| 8419 |
1/2✓ Branch 0 taken 404327 times.
✗ Branch 1 not taken.
|
404327 | THD *thd = current_thd; |
| 8420 | |||
| 8421 | Internal_error_handler_holder<View_error_handler, TABLE_LIST> view_handler( | ||
| 8422 |
1/2✓ Branch 0 taken 404327 times.
✗ Branch 1 not taken.
|
404327 | thd, context->view_error_handler, context->view_error_handler_arg); |
| 8423 | |||
| 8424 | // Bind to an instance of the stored function: | ||
| 8425 |
2/2✓ Branch 0 taken 49019 times.
✓ Branch 1 taken 355308 times.
|
404327 | if (m_sp == nullptr) { |
| 8426 |
1/2✓ Branch 0 taken 49019 times.
✗ Branch 1 not taken.
|
49019 | m_sp = sp_setup_routine(thd, enum_sp_type::FUNCTION, m_name, |
| 8427 | &thd->sp_func_cache); | ||
| 8428 |
2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 49001 times.
|
49019 | if (m_sp == nullptr) return true; |
| 8429 |
1/2✓ Branch 0 taken 49001 times.
✗ Branch 1 not taken.
|
49001 | if (sp_result_field != nullptr) { |
| 8430 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 49001 times.
|
49001 | assert(sp_result_field->table->in_use == nullptr); |
| 8431 | 49001 | sp_result_field->table->in_use = thd; | |
| 8432 | } | ||
| 8433 | } | ||
| 8434 | |||
| 8435 | /* Execute function and store the return value in the field. */ | ||
| 8436 | |||
| 8437 |
3/4✓ Branch 0 taken 404309 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 244 times.
✓ Branch 3 taken 404065 times.
|
404309 | if (execute_impl(thd)) { |
| 8438 | 244 | null_value = true; | |
| 8439 |
3/4✓ Branch 0 taken 9 times.
✓ Branch 1 taken 235 times.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
|
244 | if (thd->killed) thd->send_kill_message(); |
| 8440 | 244 | return true; | |
| 8441 | } | ||
| 8442 | |||
| 8443 | /* Check that the field (the value) is not NULL. */ | ||
| 8444 |
1/2✓ Branch 0 taken 404065 times.
✗ Branch 1 not taken.
|
404065 | null_value = sp_result_field->is_null(); |
| 8445 | |||
| 8446 | 404065 | return false; | |
| 8447 | 404327 | } | |
| 8448 | |||
| 8449 | /** | ||
| 8450 | @brief Execute function and store the return value in the field. | ||
| 8451 | Will set null_value properly only for a successful execution. | ||
| 8452 | |||
| 8453 | @note This function was intended to be the concrete implementation of | ||
| 8454 | the interface function execute. This was never realized. | ||
| 8455 | |||
| 8456 | @return The error state. | ||
| 8457 | @retval false on success | ||
| 8458 | @retval true if an error occurred. | ||
| 8459 | */ | ||
| 8460 | 404309 | bool Item_func_sp::execute_impl(THD *thd) { | |
| 8461 | 404309 | bool err_status = true; | |
| 8462 | 404309 | Sub_statement_state statement_state; | |
| 8463 | 404309 | Security_context *save_security_ctx = thd->security_context(); | |
| 8464 | 404309 | enum enum_sp_data_access access = | |
| 8465 | 404309 | (m_sp->m_chistics->daccess == SP_DEFAULT_ACCESS) | |
| 8466 |
1/2✓ Branch 0 taken 404309 times.
✗ Branch 1 not taken.
|
404309 | ? SP_DEFAULT_ACCESS_MAPPING |
| 8467 | 404309 | : m_sp->m_chistics->daccess; | |
| 8468 | |||
| 8469 |
1/2✓ Branch 0 taken 404309 times.
✗ Branch 1 not taken.
|
404309 | DBUG_TRACE; |
| 8470 | |||
| 8471 |
2/2✓ Branch 0 taken 156 times.
✓ Branch 1 taken 404153 times.
|
404309 | if (context->security_ctx) { |
| 8472 | /* Set view definer security context */ | ||
| 8473 | 156 | thd->set_security_context(context->security_ctx); | |
| 8474 | } | ||
| 8475 |
3/4✓ Branch 0 taken 404309 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 404308 times.
|
404309 | if (sp_check_access(thd)) goto error; |
| 8476 | |||
| 8477 | /* | ||
| 8478 | Throw an error if a non-deterministic function is called while | ||
| 8479 | statement-based replication (SBR) is active. | ||
| 8480 | */ | ||
| 8481 | |||
| 8482 |
4/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 187604 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 2 times.
|
187612 | if (!m_deterministic && !trust_function_creators && |
| 8483 |
6/8✓ Branch 0 taken 187612 times.
✓ Branch 1 taken 216696 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 404307 times.
|
591922 | (access == SP_CONTAINS_SQL || access == SP_MODIFIES_SQL_DATA) && |
| 8484 | 2 | (mysql_bin_log.is_open() && | |
| 8485 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | thd->variables.binlog_format == BINLOG_FORMAT_STMT)) { |
| 8486 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_error(ER_BINLOG_UNSAFE_ROUTINE, MYF(0)); |
| 8487 | 1 | goto error; | |
| 8488 | } | ||
| 8489 | |||
| 8490 | /* | ||
| 8491 | Disable the binlogging if this is not a SELECT statement. If this is a | ||
| 8492 | SELECT, leave binlogging on, so execute_function() code writes the | ||
| 8493 | function call into binlog. | ||
| 8494 | */ | ||
| 8495 |
1/2✓ Branch 0 taken 404307 times.
✗ Branch 1 not taken.
|
404307 | thd->reset_sub_statement_state(&statement_state, SUB_STMT_FUNCTION); |
| 8496 |
1/2✓ Branch 0 taken 404307 times.
✗ Branch 1 not taken.
|
404307 | err_status = m_sp->execute_function(thd, args, arg_count, sp_result_field); |
| 8497 |
1/2✓ Branch 0 taken 404307 times.
✗ Branch 1 not taken.
|
404307 | thd->restore_sub_statement_state(&statement_state); |
| 8498 | |||
| 8499 | 404309 | error: | |
| 8500 | 404309 | thd->set_security_context(save_security_ctx); | |
| 8501 | |||
| 8502 | 404309 | return err_status; | |
| 8503 | 404309 | } | |
| 8504 | |||
| 8505 | 6036 | void Item_func_sp::make_field(Send_field *tmp_field) { | |
| 8506 |
1/2✓ Branch 0 taken 6036 times.
✗ Branch 1 not taken.
|
6036 | DBUG_TRACE; |
| 8507 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6036 times.
|
6036 | assert(sp_result_field); |
| 8508 |
1/2✓ Branch 0 taken 6036 times.
✗ Branch 1 not taken.
|
6036 | sp_result_field->make_send_field(tmp_field); |
| 8509 |
1/2✓ Branch 0 taken 6036 times.
✗ Branch 1 not taken.
|
6036 | if (item_name.is_set()) tmp_field->col_name = item_name.ptr(); |
| 8510 | 6036 | } | |
| 8511 | |||
| 8512 | 334544 | Item_result Item_func_sp::result_type() const { | |
| 8513 |
1/2✓ Branch 0 taken 334544 times.
✗ Branch 1 not taken.
|
334544 | DBUG_TRACE; |
| 8514 |
3/8✓ Branch 0 taken 334544 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 334544 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 334544 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
334544 | DBUG_PRINT("info", ("m_sp = %p", (void *)m_sp)); |
| 8515 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 334544 times.
|
334544 | assert(sp_result_field); |
| 8516 |
1/2✓ Branch 0 taken 334544 times.
✗ Branch 1 not taken.
|
669088 | return sp_result_field->result_type(); |
| 8517 | 334544 | } | |
| 8518 | |||
| 8519 | 205 | bool Item_func_found_rows::itemize(Parse_context *pc, Item **res) { | |
| 8520 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 205 times.
|
205 | if (skip_itemize(res)) return false; |
| 8521 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 205 times.
|
205 | if (super::itemize(pc, res)) return true; |
| 8522 | 205 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 8523 | 205 | pc->thd->lex->safe_to_cache_query = false; | |
| 8524 | 205 | push_warning(current_thd, Sql_condition::SL_WARNING, | |
| 8525 | ER_WARN_DEPRECATED_SYNTAX, | ||
| 8526 | 205 | ER_THD(current_thd, ER_WARN_DEPRECATED_FOUND_ROWS)); | |
| 8527 | 205 | return false; | |
| 8528 | } | ||
| 8529 | |||
| 8530 | 178 | longlong Item_func_found_rows::val_int() { | |
| 8531 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 178 times.
|
178 | assert(fixed == 1); |
| 8532 | 178 | return current_thd->found_rows(); | |
| 8533 | } | ||
| 8534 | |||
| 8535 | 120 | Field *Item_func_sp::tmp_table_field(TABLE *) { | |
| 8536 |
1/2✓ Branch 0 taken 120 times.
✗ Branch 1 not taken.
|
120 | DBUG_TRACE; |
| 8537 | |||
| 8538 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 120 times.
|
120 | assert(sp_result_field); |
| 8539 | 120 | return sp_result_field; | |
| 8540 | 120 | } | |
| 8541 | |||
| 8542 | /** | ||
| 8543 | @brief Checks if requested access to function can be granted to user. | ||
| 8544 | If function isn't found yet, it searches function first. | ||
| 8545 | If function can't be found or user don't have requested access | ||
| 8546 | error is raised. | ||
| 8547 | |||
| 8548 | @param thd thread handler | ||
| 8549 | |||
| 8550 | @return Indication if the access was granted or not. | ||
| 8551 | @retval false Access is granted. | ||
| 8552 | @retval true Requested access can't be granted or function doesn't exists. | ||
| 8553 | |||
| 8554 | */ | ||
| 8555 | |||
| 8556 | 495527 | bool Item_func_sp::sp_check_access(THD *thd) { | |
| 8557 |
1/2✓ Branch 0 taken 495527 times.
✗ Branch 1 not taken.
|
495527 | DBUG_TRACE; |
| 8558 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 495527 times.
|
495527 | assert(m_sp); |
| 8559 |
3/4✓ Branch 0 taken 495527 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 495524 times.
|
495527 | if (check_routine_access(thd, EXECUTE_ACL, m_sp->m_db.str, m_sp->m_name.str, |
| 8560 | false, false)) | ||
| 8561 | 3 | return true; | |
| 8562 | |||
| 8563 | 495524 | return false; | |
| 8564 | 495527 | } | |
| 8565 | |||
| 8566 | 114308 | bool Item_func_sp::fix_fields(THD *thd, Item **ref) { | |
| 8567 | 114308 | Security_context *save_security_ctx = thd->security_context(); | |
| 8568 | |||
| 8569 |
1/2✓ Branch 0 taken 114308 times.
✗ Branch 1 not taken.
|
114308 | DBUG_TRACE; |
| 8570 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 114308 times.
|
114308 | assert(fixed == 0); |
| 8571 | |||
| 8572 | /* | ||
| 8573 | Checking privileges to execute the function while creating view and | ||
| 8574 | executing the function of select. | ||
| 8575 | */ | ||
| 8576 |
4/4✓ Branch 0 taken 91230 times.
✓ Branch 1 taken 23078 times.
✓ Branch 2 taken 36500 times.
✓ Branch 3 taken 77808 times.
|
205538 | if (!thd->lex->is_view_context_analysis() || |
| 8577 |
2/2✓ Branch 0 taken 13422 times.
✓ Branch 1 taken 77808 times.
|
91230 | (thd->lex->sql_command == SQLCOM_CREATE_VIEW)) { |
| 8578 |
2/2✓ Branch 0 taken 199 times.
✓ Branch 1 taken 36301 times.
|
36500 | if (context->security_ctx) { |
| 8579 | /* Set view definer security context */ | ||
| 8580 | 199 | thd->set_security_context(context->security_ctx); | |
| 8581 | } | ||
| 8582 | |||
| 8583 | /* | ||
| 8584 | Check whether user has execute privilege or not | ||
| 8585 | */ | ||
| 8586 | |||
| 8587 | Internal_error_handler_holder<View_error_handler, TABLE_LIST> view_handler( | ||
| 8588 |
1/2✓ Branch 0 taken 36500 times.
✗ Branch 1 not taken.
|
36500 | thd, context->view_error_handler, context->view_error_handler_arg); |
| 8589 | |||
| 8590 | 73000 | bool res = check_routine_access(thd, EXECUTE_ACL, m_name->m_db.str, | |
| 8591 |
1/2✓ Branch 0 taken 36500 times.
✗ Branch 1 not taken.
|
36500 | m_name->m_name.str, false, false); |
| 8592 | 36500 | thd->set_security_context(save_security_ctx); | |
| 8593 | |||
| 8594 |
2/2✓ Branch 0 taken 35 times.
✓ Branch 1 taken 36465 times.
|
36500 | if (res) return res; |
| 8595 |
2/2✓ Branch 0 taken 36465 times.
✓ Branch 1 taken 35 times.
|
36500 | } |
| 8596 | |||
| 8597 | /* | ||
| 8598 | We must call init_result_field before Item_func::fix_fields() | ||
| 8599 | to make m_sp and result_field members available to resolve_type(), | ||
| 8600 | which is called from Item_func::fix_fields(). | ||
| 8601 | */ | ||
| 8602 |
3/4✓ Branch 0 taken 114273 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
✓ Branch 3 taken 114185 times.
|
114273 | if (init_result_field(thd)) return true; |
| 8603 | |||
| 8604 | 114185 | sp_pcontext *sp_ctx = m_sp->get_root_parsing_context(); | |
| 8605 | |||
| 8606 |
3/4✓ Branch 0 taken 114185 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 114180 times.
|
114185 | if (arg_count != sp_ctx->context_var_count()) { |
| 8607 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
5 | my_error(ER_SP_WRONG_NO_OF_ARGS, MYF(0), "FUNCTION", m_sp->m_qname.str, |
| 8608 | sp_ctx->context_var_count(), arg_count); | ||
| 8609 | 5 | return true; | |
| 8610 | } | ||
| 8611 | |||
| 8612 |
2/4✓ Branch 0 taken 114180 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 114180 times.
|
114180 | if (Item_func::fix_fields(thd, ref)) return true; |
| 8613 | |||
| 8614 |
2/2✓ Branch 0 taken 121175 times.
✓ Branch 1 taken 114180 times.
|
235355 | for (uint i = 0; i < arg_count; i++) { |
| 8615 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 121170 times.
|
121175 | if (args[0]->data_type() == MYSQL_TYPE_INVALID) { |
| 8616 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | sp_variable *var = sp_ctx->find_variable(i); |
| 8617 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (args[0]->propagate_type( |
| 8618 | thd, | ||
| 8619 | 5 | is_numeric_type(var->type) | |
| 8620 |
4/6✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 5 times.
|
12 | ? Type_properties(var->type, var->field_def.is_unsigned) |
| 8621 | 2 | : is_string_type(var->type) | |
| 8622 | ? Type_properties(var->type, var->field_def.charset) | ||
| 8623 | : Type_properties(var->type))) | ||
| 8624 | ✗ | return true; | |
| 8625 | } | ||
| 8626 | } | ||
| 8627 | |||
| 8628 |
2/2✓ Branch 0 taken 91218 times.
✓ Branch 1 taken 22962 times.
|
114180 | if (thd->lex->is_view_context_analysis()) { |
| 8629 | /* | ||
| 8630 | Here we check privileges of the stored routine only during view | ||
| 8631 | creation, in order to validate the view. A runtime check is | ||
| 8632 | performed in Item_func_sp::execute(), and this method is not | ||
| 8633 | called during context analysis. Notice, that during view | ||
| 8634 | creation we do not infer into stored routine bodies and do not | ||
| 8635 | check privileges of its statements, which would probably be a | ||
| 8636 | good idea especially if the view has SQL SECURITY DEFINER and | ||
| 8637 | the used stored procedure has SQL SECURITY DEFINER. | ||
| 8638 | */ | ||
| 8639 |
3/4✓ Branch 0 taken 91218 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 91216 times.
|
91218 | if (sp_check_access(thd)) return true; |
| 8640 | /* | ||
| 8641 | Try to set and restore the security context to see whether it's valid | ||
| 8642 | */ | ||
| 8643 | Security_context *save_security_context; | ||
| 8644 |
2/4✓ Branch 0 taken 91216 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 91216 times.
|
91216 | if (m_sp->set_security_ctx(thd, &save_security_context)) return true; |
| 8645 |
1/2✓ Branch 0 taken 91216 times.
✗ Branch 1 not taken.
|
91216 | m_sp->m_security_ctx.restore_security_context(thd, save_security_context); |
| 8646 | } | ||
| 8647 | |||
| 8648 | // Cleanup immediately, thus execute() will always attach to the routine. | ||
| 8649 |
1/2✓ Branch 0 taken 114178 times.
✗ Branch 1 not taken.
|
114178 | cleanup(); |
| 8650 | |||
| 8651 | 114178 | return false; | |
| 8652 | 114308 | } | |
| 8653 | |||
| 8654 | 9931 | void Item_func_sp::update_used_tables() { | |
| 8655 | 9931 | Item_func::update_used_tables(); | |
| 8656 | |||
| 8657 | /* This is reset by Item_func::update_used_tables(). */ | ||
| 8658 | 9931 | set_stored_program(); | |
| 8659 | 9931 | } | |
| 8660 | |||
| 8661 | 103 | void Item_func_sp::fix_after_pullout(Query_block *parent_query_block, | |
| 8662 | Query_block *removed_query_block) { | ||
| 8663 | 103 | Item_func::fix_after_pullout(parent_query_block, removed_query_block); | |
| 8664 | 103 | } | |
| 8665 | |||
| 8666 | /* | ||
| 8667 | uuid_short handling. | ||
| 8668 | |||
| 8669 | The short uuid is defined as a longlong that contains the following bytes: | ||
| 8670 | |||
| 8671 | Bytes Comment | ||
| 8672 | 1 Server_id & 255 | ||
| 8673 | 4 Startup time of server in seconds | ||
| 8674 | 3 Incrementor | ||
| 8675 | |||
| 8676 | This means that an uuid is guaranteed to be unique | ||
| 8677 | even in a replication environment if the following holds: | ||
| 8678 | |||
| 8679 | - The last byte of the server id is unique | ||
| 8680 | - If you between two shutdown of the server don't get more than | ||
| 8681 | an average of 2^24 = 16M calls to uuid_short() per second. | ||
| 8682 | */ | ||
| 8683 | |||
| 8684 | ulonglong uuid_value; | ||
| 8685 | |||
| 8686 | 9786 | void uuid_short_init() { | |
| 8687 | 9786 | uuid_value = | |
| 8688 | 9786 | ((((ulonglong)server_id) << 56) + (((ulonglong)server_start_time) << 24)); | |
| 8689 | 9786 | } | |
| 8690 | |||
| 8691 | 79 | bool Item_func_uuid_short::itemize(Parse_context *pc, Item **res) { | |
| 8692 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79 times.
|
79 | if (skip_itemize(res)) return false; |
| 8693 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79 times.
|
79 | if (super::itemize(pc, res)) return true; |
| 8694 | 79 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 8695 | 79 | pc->thd->lex->safe_to_cache_query = false; | |
| 8696 | 79 | return false; | |
| 8697 | } | ||
| 8698 | |||
| 8699 | 75 | longlong Item_func_uuid_short::val_int() { | |
| 8700 | ulonglong val; | ||
| 8701 | 75 | mysql_mutex_lock(&LOCK_uuid_generator); | |
| 8702 | 75 | val = uuid_value++; | |
| 8703 | 75 | mysql_mutex_unlock(&LOCK_uuid_generator); | |
| 8704 | 75 | return (longlong)val; | |
| 8705 | } | ||
| 8706 | |||
| 8707 | 6276 | bool Item_func_version::itemize(Parse_context *pc, Item **res) { | |
| 8708 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6276 times.
|
6276 | if (skip_itemize(res)) return false; |
| 8709 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6276 times.
|
6276 | if (super::itemize(pc, res)) return true; |
| 8710 | 6276 | pc->thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); | |
| 8711 | 6276 | return false; | |
| 8712 | } | ||
| 8713 | |||
| 8714 | /** | ||
| 8715 | Check if schema and table are hidden by NDB engine. | ||
| 8716 | |||
| 8717 | @param thd Thread handle. | ||
| 8718 | @param schema_name Schema name. | ||
| 8719 | @param table_name Table name. | ||
| 8720 | |||
| 8721 | @retval true If schema and table are hidden by NDB. | ||
| 8722 | @retval false If schema and table are not hidden by NDB. | ||
| 8723 | */ | ||
| 8724 | |||
| 8725 | 22202836 | static inline bool is_hidden_by_ndb(THD *thd, String *schema_name, | |
| 8726 | String *table_name) { | ||
| 8727 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22202836 times.
|
22202836 | if (!strncmp(schema_name->ptr(), "ndb", 3)) { |
| 8728 | ✗ | List<LEX_STRING> list; | |
| 8729 | |||
| 8730 | // Check if schema is of ndb and if it is hidden by it. | ||
| 8731 | ✗ | LEX_STRING sch_name = schema_name->lex_string(); | |
| 8732 | ✗ | list.push_back(&sch_name); | |
| 8733 | ✗ | ha_find_files(thd, nullptr, nullptr, nullptr, true, &list); | |
| 8734 | ✗ | if (list.elements == 0) { | |
| 8735 | // Schema is hidden by ndb engine. | ||
| 8736 | ✗ | return true; | |
| 8737 | } | ||
| 8738 | |||
| 8739 | // Check if table is hidden by ndb. | ||
| 8740 | ✗ | if (table_name != nullptr) { | |
| 8741 | ✗ | list.clear(); | |
| 8742 | ✗ | LEX_STRING tbl_name = table_name->lex_string(); | |
| 8743 | ✗ | list.push_back(&tbl_name); | |
| 8744 | ✗ | ha_find_files(thd, schema_name->ptr(), nullptr, nullptr, false, &list); | |
| 8745 | ✗ | if (list.elements == 0) { | |
| 8746 | // Table is hidden by ndb engine. | ||
| 8747 | ✗ | return true; | |
| 8748 | } | ||
| 8749 | } | ||
| 8750 | } | ||
| 8751 | |||
| 8752 | 22202836 | return false; | |
| 8753 | } | ||
| 8754 | |||
| 8755 | /** | ||
| 8756 | @brief | ||
| 8757 | INFORMATION_SCHEMA picks metadata from DD using system views. | ||
| 8758 | In order for INFORMATION_SCHEMA to skip listing database for which | ||
| 8759 | the user does not have rights, the following internal functions are used. | ||
| 8760 | |||
| 8761 | Syntax: | ||
| 8762 | int CAN_ACCCESS_DATABASE(schema_name); | ||
| 8763 | |||
| 8764 | @returns, | ||
| 8765 | 1 - If current user has access. | ||
| 8766 | 0 - If not. | ||
| 8767 | */ | ||
| 8768 | |||
| 8769 | 153841 | longlong Item_func_can_access_database::val_int() { | |
| 8770 |
1/2✓ Branch 0 taken 153841 times.
✗ Branch 1 not taken.
|
153841 | DBUG_TRACE; |
| 8771 | |||
| 8772 | // Read schema_name | ||
| 8773 | 153841 | String schema_name; | |
| 8774 |
1/2✓ Branch 0 taken 153841 times.
✗ Branch 1 not taken.
|
153841 | String *schema_name_ptr = args[0]->val_str(&schema_name); |
| 8775 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 153840 times.
|
153841 | if (schema_name_ptr == nullptr) { |
| 8776 | 1 | null_value = true; | |
| 8777 | 1 | return 0; | |
| 8778 | } | ||
| 8779 | |||
| 8780 | // Make sure we have safe string to access. | ||
| 8781 |
1/2✓ Branch 0 taken 153840 times.
✗ Branch 1 not taken.
|
153840 | schema_name_ptr->c_ptr_safe(); |
| 8782 | |||
| 8783 | // Check if schema is hidden. | ||
| 8784 |
1/2✓ Branch 0 taken 153840 times.
✗ Branch 1 not taken.
|
153840 | THD *thd = current_thd; |
| 8785 |
2/4✓ Branch 0 taken 153840 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 153840 times.
|
153840 | if (is_hidden_by_ndb(thd, schema_name_ptr, nullptr)) return 0; |
| 8786 | |||
| 8787 | // Skip INFORMATION_SCHEMA database | ||
| 8788 |
3/4✓ Branch 0 taken 153840 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25450 times.
✓ Branch 3 taken 128390 times.
|
153840 | if (is_infoschema_db(schema_name_ptr->ptr())) return 1; |
| 8789 | |||
| 8790 | // Skip PERFORMANCE_SCHEMA database | ||
| 8791 |
3/4✓ Branch 0 taken 128390 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25439 times.
✓ Branch 3 taken 102951 times.
|
128390 | if (is_perfschema_db(schema_name_ptr->ptr())) return 1; |
| 8792 | |||
| 8793 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 102951 times.
|
102951 | if (lower_case_table_names == 2) { |
| 8794 | /* | ||
| 8795 | ACL code assumes that in l-c-t-n > 0 modes schema name passed to it | ||
| 8796 | is in lower case. | ||
| 8797 | */ | ||
| 8798 | ✗ | my_casedn_str(files_charset_info, schema_name_ptr->ptr()); | |
| 8799 | } | ||
| 8800 | |||
| 8801 | // Check access | ||
| 8802 | 102951 | Security_context *sctx = thd->security_context(); | |
| 8803 |
8/16✓ Branch 0 taken 102951 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 102951 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 147 times.
✓ Branch 5 taken 102804 times.
✓ Branch 6 taken 102951 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 102951 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 33 times.
✓ Branch 11 taken 102918 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
|
103098 | if (!(sctx->master_access(schema_name_ptr->ptr()) & |
| 8804 | 147 | (DB_OP_ACLS | SHOW_DB_ACL) || | |
| 8805 |
6/10✓ Branch 0 taken 147 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 147 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 147 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 147 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 33 times.
✓ Branch 9 taken 114 times.
|
147 | acl_get(thd, sctx->host().str, sctx->ip().str, sctx->priv_user().str, |
| 8806 | 147 | schema_name_ptr->ptr(), false) || | |
| 8807 |
2/4✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
|
33 | !check_grant_db(thd, schema_name_ptr->ptr()))) { |
| 8808 | 33 | return 0; | |
| 8809 | } | ||
| 8810 | |||
| 8811 | 102918 | return 1; | |
| 8812 | 153841 | } | |
| 8813 | |||
| 8814 | 2073794 | static bool check_table_and_trigger_access(Item **args, bool check_trigger_acl, | |
| 8815 | bool *null_value) { | ||
| 8816 |
1/2✓ Branch 0 taken 2073794 times.
✗ Branch 1 not taken.
|
2073794 | DBUG_TRACE; |
| 8817 | |||
| 8818 | // Read schema_name, table_name | ||
| 8819 | 2073794 | String schema_name; | |
| 8820 |
1/2✓ Branch 0 taken 2073794 times.
✗ Branch 1 not taken.
|
2073794 | String *schema_name_ptr = args[0]->val_str(&schema_name); |
| 8821 | 2073794 | String table_name; | |
| 8822 |
1/2✓ Branch 0 taken 2073794 times.
✗ Branch 1 not taken.
|
2073794 | String *table_name_ptr = args[1]->val_str(&table_name); |
| 8823 |
3/4✓ Branch 0 taken 2073792 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2073792 times.
|
2073794 | if (schema_name_ptr == nullptr || table_name_ptr == nullptr) { |
| 8824 | 2 | *null_value = true; | |
| 8825 | 2 | return false; | |
| 8826 | } | ||
| 8827 | |||
| 8828 |
1/2✓ Branch 0 taken 2073792 times.
✗ Branch 1 not taken.
|
2073792 | const char *sch_name = schema_name_ptr->c_ptr_safe(); |
| 8829 |
1/2✓ Branch 0 taken 2073792 times.
✗ Branch 1 not taken.
|
2073792 | const char *tbl_name = table_name_ptr->c_ptr_safe(); |
| 8830 | |||
| 8831 | // Check if table is hidden. | ||
| 8832 |
1/2✓ Branch 0 taken 2073792 times.
✗ Branch 1 not taken.
|
2073792 | THD *thd = current_thd; |
| 8833 |
2/4✓ Branch 0 taken 2073792 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2073792 times.
|
2073792 | if (is_hidden_by_ndb(thd, schema_name_ptr, table_name_ptr)) return false; |
| 8834 | |||
| 8835 | // Don't show compression dictionary tables in "SHOW TABLES" | ||
| 8836 |
2/4✓ Branch 0 taken 2073792 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2073792 times.
✗ Branch 3 not taken.
|
2073792 | if (compression_dict::is_hardcoded(dd::String_type(sch_name), |
| 8837 |
3/4✓ Branch 0 taken 2073792 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50640 times.
✓ Branch 3 taken 2023152 times.
|
4147584 | dd::String_type(tbl_name))) { |
| 8838 | 50640 | return false; | |
| 8839 | } | ||
| 8840 | |||
| 8841 | // Skip INFORMATION_SCHEMA database | ||
| 8842 |
3/4✓ Branch 0 taken 2023152 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30417 times.
✓ Branch 3 taken 1992735 times.
|
2023152 | if (is_infoschema_db(schema_name_ptr->ptr())) return true; |
| 8843 | |||
| 8844 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1992735 times.
|
1992735 | if (lower_case_table_names == 2) { |
| 8845 | /* | ||
| 8846 | ACL code assumes that in l-c-t-n > 0 modes schema and table names | ||
| 8847 | passed to it are in lower case. | ||
| 8848 | */ | ||
| 8849 | ✗ | schema_name_ptr->length( | |
| 8850 | ✗ | my_casedn_str(files_charset_info, schema_name_ptr->ptr())); | |
| 8851 | ✗ | table_name_ptr->length( | |
| 8852 | ✗ | my_casedn_str(files_charset_info, table_name_ptr->ptr())); | |
| 8853 | } | ||
| 8854 | |||
| 8855 | // Check access | ||
| 8856 | 1992735 | ulong db_access = 0; | |
| 8857 |
2/4✓ Branch 0 taken 1992735 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1992735 times.
|
1992735 | if (check_access(thd, SELECT_ACL, schema_name_ptr->ptr(), &db_access, nullptr, |
| 8858 | false, true)) | ||
| 8859 | ✗ | return false; | |
| 8860 | |||
| 8861 |
1/2✓ Branch 0 taken 1992735 times.
✗ Branch 1 not taken.
|
1992735 | TABLE_LIST table_list; |
| 8862 | 1992735 | table_list.db = schema_name_ptr->ptr(); | |
| 8863 | 1992735 | table_list.db_length = schema_name_ptr->length(); | |
| 8864 | 1992735 | table_list.table_name = table_name_ptr->ptr(); | |
| 8865 | 1992735 | table_list.table_name_length = table_name_ptr->length(); | |
| 8866 | 1992735 | table_list.grant.privilege = db_access; | |
| 8867 | |||
| 8868 |
2/2✓ Branch 0 taken 1942182 times.
✓ Branch 1 taken 50553 times.
|
1992735 | if (check_trigger_acl == false) { |
| 8869 |
2/2✓ Branch 0 taken 1940505 times.
✓ Branch 1 taken 1677 times.
|
1942182 | if (db_access & TABLE_OP_ACLS) return true; |
| 8870 | |||
| 8871 | // Check table access | ||
| 8872 |
3/4✓ Branch 0 taken 1677 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1584 times.
✓ Branch 3 taken 93 times.
|
1677 | if (check_grant(thd, TABLE_OP_ACLS, &table_list, true, 1, true)) |
| 8873 | 1584 | return false; | |
| 8874 | } else // Trigger check. | ||
| 8875 | { | ||
| 8876 | // Check trigger access | ||
| 8877 |
3/4✓ Branch 0 taken 50553 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✓ Branch 3 taken 50529 times.
|
101106 | if (check_trigger_acl && |
| 8878 |
3/4✓ Branch 0 taken 50553 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✓ Branch 3 taken 50529 times.
|
50553 | check_table_access(thd, TRIGGER_ACL, &table_list, false, 1, true)) |
| 8879 | 24 | return false; | |
| 8880 | } | ||
| 8881 | |||
| 8882 | 50622 | return true; | |
| 8883 | 2073794 | } | |
| 8884 | |||
| 8885 | /** | ||
| 8886 | @brief | ||
| 8887 | INFORMATION_SCHEMA picks metadata from new DD using system views. | ||
| 8888 | In order for INFORMATION_SCHEMA to skip listing table for which | ||
| 8889 | the user does not have rights, the following UDF's is used. | ||
| 8890 | |||
| 8891 | Syntax: | ||
| 8892 | int CAN_ACCCESS_TABLE(schema_name, table_name); | ||
| 8893 | |||
| 8894 | @returns, | ||
| 8895 | 1 - If current user has access. | ||
| 8896 | 0 - If not. | ||
| 8897 | */ | ||
| 8898 | 2023240 | longlong Item_func_can_access_table::val_int() { | |
| 8899 |
1/2✓ Branch 0 taken 2023240 times.
✗ Branch 1 not taken.
|
2023240 | DBUG_TRACE; |
| 8900 | |||
| 8901 |
3/4✓ Branch 0 taken 2023240 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1971015 times.
✓ Branch 3 taken 52225 times.
|
2023240 | if (check_table_and_trigger_access(args, false, &null_value)) return 1; |
| 8902 | |||
| 8903 | 52225 | return 0; | |
| 8904 | 2023240 | } | |
| 8905 | |||
| 8906 | /** | ||
| 8907 | @brief | ||
| 8908 | INFORMATION_SCHEMA picks metadata from new DD using system views. | ||
| 8909 | In order for INFORMATION_SCHEMA to skip listing user accpounts for which | ||
| 8910 | the user does not have rights, the following SQL function is used. | ||
| 8911 | |||
| 8912 | Syntax: | ||
| 8913 | int CAN_ACCCESS_USER(user_part, host_part); | ||
| 8914 | |||
| 8915 | @returns, | ||
| 8916 | 1 - If current user has access. | ||
| 8917 | 0 - If not. | ||
| 8918 | |||
| 8919 | @sa @ref acl_can_access_user | ||
| 8920 | */ | ||
| 8921 | 173 | longlong Item_func_can_access_user::val_int() { | |
| 8922 |
1/2✓ Branch 0 taken 173 times.
✗ Branch 1 not taken.
|
173 | DBUG_TRACE; |
| 8923 | |||
| 8924 |
1/2✓ Branch 0 taken 173 times.
✗ Branch 1 not taken.
|
173 | THD *thd = current_thd; |
| 8925 | // Read user, host | ||
| 8926 | 173 | String user_name; | |
| 8927 |
1/2✓ Branch 0 taken 173 times.
✗ Branch 1 not taken.
|
173 | String *user_name_ptr = args[0]->val_str(&user_name); |
| 8928 | 173 | String host_name; | |
| 8929 |
1/2✓ Branch 0 taken 173 times.
✗ Branch 1 not taken.
|
173 | String *host_name_ptr = args[1]->val_str(&host_name); |
| 8930 |
3/4✓ Branch 0 taken 172 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 172 times.
|
173 | if (host_name_ptr == nullptr || user_name_ptr == nullptr) { |
| 8931 | 1 | null_value = true; | |
| 8932 | 1 | return 0; | |
| 8933 | } | ||
| 8934 | |||
| 8935 | // Make sure we have safe string to access. | ||
| 8936 |
1/2✓ Branch 0 taken 172 times.
✗ Branch 1 not taken.
|
172 | host_name_ptr->c_ptr_safe(); |
| 8937 |
1/2✓ Branch 0 taken 172 times.
✗ Branch 1 not taken.
|
172 | user_name_ptr->c_ptr_safe(); |
| 8938 | 172 | MYSQL_LEX_STRING user_str = {const_cast<char *>(user_name_ptr->ptr()), | |
| 8939 | 172 | user_name_ptr->length()}; | |
| 8940 | MYSQL_LEX_STRING | ||
| 8941 | 172 | host_str = {const_cast<char *>(host_name_ptr->ptr()), | |
| 8942 | 172 | host_name_ptr->length()}; | |
| 8943 |
1/2✓ Branch 0 taken 172 times.
✗ Branch 1 not taken.
|
172 | LEX_USER user; |
| 8944 |
2/4✓ Branch 0 taken 172 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 172 times.
|
172 | if (!LEX_USER::init(&user, thd, &user_str, &host_str)) return 0; |
| 8945 | |||
| 8946 |
3/4✓ Branch 0 taken 172 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50 times.
✓ Branch 3 taken 122 times.
|
172 | return acl_can_access_user(thd, &user) ? 1 : 0; |
| 8947 | 173 | } | |
| 8948 | |||
| 8949 | /** | ||
| 8950 | @brief | ||
| 8951 | INFORMATION_SCHEMA picks metadata from new DD using system views. In | ||
| 8952 | order for INFORMATION_SCHEMA to skip listing table for which the user | ||
| 8953 | does not have rights on triggers, the following UDF's is used. | ||
| 8954 | |||
| 8955 | Syntax: | ||
| 8956 | int CAN_ACCCESS_TRIGGER(schema_name, table_name); | ||
| 8957 | |||
| 8958 | @returns, | ||
| 8959 | 1 - If current user has access. | ||
| 8960 | 0 - If not. | ||
| 8961 | */ | ||
| 8962 | 50554 | longlong Item_func_can_access_trigger::val_int() { | |
| 8963 |
1/2✓ Branch 0 taken 50554 times.
✗ Branch 1 not taken.
|
50554 | DBUG_TRACE; |
| 8964 | |||
| 8965 |
3/4✓ Branch 0 taken 50554 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50529 times.
✓ Branch 3 taken 25 times.
|
50554 | if (check_table_and_trigger_access(args, true, &null_value)) return 1; |
| 8966 | |||
| 8967 | 25 | return 0; | |
| 8968 | 50554 | } | |
| 8969 | |||
| 8970 | /** | ||
| 8971 | @brief | ||
| 8972 | INFORMATION_SCHEMA picks metadata from DD using system views. In | ||
| 8973 | order for INFORMATION_SCHEMA to skip listing routine for which the user | ||
| 8974 | does not have rights, the following UDF's is used. | ||
| 8975 | |||
| 8976 | Syntax: | ||
| 8977 | int CAN_ACCESS_ROUTINE(schema_name, name, type, user, definer, | ||
| 8978 | check_full_access); | ||
| 8979 | |||
| 8980 | @returns, | ||
| 8981 | 1 - If current user has access. | ||
| 8982 | 0 - If not. | ||
| 8983 | */ | ||
| 8984 | 450406 | longlong Item_func_can_access_routine::val_int() { | |
| 8985 |
1/2✓ Branch 0 taken 450406 times.
✗ Branch 1 not taken.
|
450406 | DBUG_TRACE; |
| 8986 | |||
| 8987 | // Read schema_name, table_name | ||
| 8988 | 450406 | String schema_name; | |
| 8989 | 450406 | String routine_name; | |
| 8990 | 450406 | String type; | |
| 8991 | 450406 | String definer; | |
| 8992 |
1/2✓ Branch 0 taken 450406 times.
✗ Branch 1 not taken.
|
450406 | String *schema_name_ptr = args[0]->val_str(&schema_name); |
| 8993 |
1/2✓ Branch 0 taken 450406 times.
✗ Branch 1 not taken.
|
450406 | String *routine_name_ptr = args[1]->val_str(&routine_name); |
| 8994 |
1/2✓ Branch 0 taken 450406 times.
✗ Branch 1 not taken.
|
450406 | String *type_ptr = args[2]->val_str(&type); |
| 8995 |
1/2✓ Branch 0 taken 450406 times.
✗ Branch 1 not taken.
|
450406 | String *definer_ptr = args[3]->val_str(&definer); |
| 8996 |
1/2✓ Branch 0 taken 450406 times.
✗ Branch 1 not taken.
|
450406 | bool check_full_access = args[4]->val_int(); |
| 8997 |
4/6✓ Branch 0 taken 450405 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 450405 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 450405 times.
✗ Branch 5 not taken.
|
450406 | if (schema_name_ptr == nullptr || routine_name_ptr == nullptr || |
| 8998 |
2/4✓ Branch 0 taken 450405 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 450405 times.
|
450405 | type_ptr == nullptr || definer_ptr == nullptr || args[4]->null_value) { |
| 8999 | 1 | null_value = true; | |
| 9000 | 1 | return 0; | |
| 9001 | } | ||
| 9002 | |||
| 9003 | // Make strings safe. | ||
| 9004 |
1/2✓ Branch 0 taken 450405 times.
✗ Branch 1 not taken.
|
450405 | schema_name_ptr->c_ptr_safe(); |
| 9005 |
1/2✓ Branch 0 taken 450405 times.
✗ Branch 1 not taken.
|
450405 | routine_name_ptr->c_ptr_safe(); |
| 9006 |
1/2✓ Branch 0 taken 450405 times.
✗ Branch 1 not taken.
|
450405 | type_ptr->c_ptr_safe(); |
| 9007 |
1/2✓ Branch 0 taken 450405 times.
✗ Branch 1 not taken.
|
450405 | definer_ptr->c_ptr_safe(); |
| 9008 | |||
| 9009 | 450405 | bool is_procedure = (strcmp(type_ptr->ptr(), "PROCEDURE") == 0); | |
| 9010 | |||
| 9011 | // Skip INFORMATION_SCHEMA database | ||
| 9012 |
4/6✓ Branch 0 taken 450405 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 450405 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1665 times.
✓ Branch 5 taken 448740 times.
|
900810 | if (is_infoschema_db(schema_name_ptr->ptr()) || |
| 9013 |
3/4✓ Branch 0 taken 450405 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1665 times.
✓ Branch 3 taken 448740 times.
|
450405 | !my_strcasecmp(system_charset_info, schema_name_ptr->ptr(), "sys")) |
| 9014 | 1665 | return 1; | |
| 9015 | |||
| 9016 | /* | ||
| 9017 | Check if user has full access to the routine properties (i.e including | ||
| 9018 | stored routine code), or partial access (i.e to view its other properties). | ||
| 9019 | */ | ||
| 9020 | |||
| 9021 | char user_name_holder[USERNAME_LENGTH + 1]; | ||
| 9022 | 448740 | LEX_STRING user_name = {user_name_holder, USERNAME_LENGTH}; | |
| 9023 | |||
| 9024 | char host_name_holder[HOSTNAME_LENGTH + 1]; | ||
| 9025 | 448740 | LEX_STRING host_name = {host_name_holder, HOSTNAME_LENGTH}; | |
| 9026 | |||
| 9027 |
1/2✓ Branch 0 taken 448740 times.
✗ Branch 1 not taken.
|
448740 | parse_user(definer_ptr->ptr(), definer_ptr->length(), user_name.str, |
| 9028 | &user_name.length, host_name.str, &host_name.length); | ||
| 9029 | |||
| 9030 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 448740 times.
|
448740 | if (lower_case_table_names == 2) { |
| 9031 | /* | ||
| 9032 | ACL code assumes that in l-c-t-n > 0 modes schema name passed to it | ||
| 9033 | is in lower case. | ||
| 9034 | */ | ||
| 9035 | ✗ | my_casedn_str(files_charset_info, schema_name_ptr->ptr()); | |
| 9036 | } | ||
| 9037 | |||
| 9038 |
1/2✓ Branch 0 taken 448740 times.
✗ Branch 1 not taken.
|
448740 | THD *thd = current_thd; |
| 9039 |
1/2✓ Branch 0 taken 448740 times.
✗ Branch 1 not taken.
|
448740 | bool full_access = has_full_view_routine_access(thd, schema_name_ptr->ptr(), |
| 9040 | 448740 | user_name.str, host_name.str); | |
| 9041 | |||
| 9042 |
2/2✓ Branch 0 taken 223790 times.
✓ Branch 1 taken 224950 times.
|
448740 | if (check_full_access) { |
| 9043 |
2/2✓ Branch 0 taken 223763 times.
✓ Branch 1 taken 27 times.
|
223790 | return full_access ? 1 : 0; |
| 9044 |
7/8✓ Branch 0 taken 102 times.
✓ Branch 1 taken 224848 times.
✓ Branch 2 taken 102 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 51 times.
✓ Branch 5 taken 51 times.
✓ Branch 6 taken 51 times.
✓ Branch 7 taken 224899 times.
|
225052 | } else if (!full_access && !has_partial_view_routine_access( |
| 9045 | 102 | thd, schema_name_ptr->ptr(), | |
| 9046 | 102 | routine_name_ptr->ptr(), is_procedure)) { | |
| 9047 | 51 | return 0; | |
| 9048 | } | ||
| 9049 | |||
| 9050 | 224899 | return 1; | |
| 9051 | 450406 | } | |
| 9052 | |||
| 9053 | /** | ||
| 9054 | @brief | ||
| 9055 | INFORMATION_SCHEMA picks metadata from DD using system views. | ||
| 9056 | In order for INFORMATION_SCHEMA to skip listing event for which | ||
| 9057 | the user does not have rights, the following internal functions are used. | ||
| 9058 | |||
| 9059 | Syntax: | ||
| 9060 | int CAN_ACCCESS_EVENT(schema_name); | ||
| 9061 | |||
| 9062 | @returns, | ||
| 9063 | 1 - If current user has access. | ||
| 9064 | 0 - If not. | ||
| 9065 | */ | ||
| 9066 | |||
| 9067 | 1128 | longlong Item_func_can_access_event::val_int() { | |
| 9068 |
1/2✓ Branch 0 taken 1128 times.
✗ Branch 1 not taken.
|
1128 | DBUG_TRACE; |
| 9069 | |||
| 9070 | // Read schema_name | ||
| 9071 | 1128 | String schema_name; | |
| 9072 |
1/2✓ Branch 0 taken 1128 times.
✗ Branch 1 not taken.
|
1128 | String *schema_name_ptr = args[0]->val_str(&schema_name); |
| 9073 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1127 times.
|
1128 | if (schema_name_ptr == nullptr) { |
| 9074 | 1 | null_value = true; | |
| 9075 | 1 | return 0; | |
| 9076 | } | ||
| 9077 | |||
| 9078 | // Make sure we have safe string to access. | ||
| 9079 |
1/2✓ Branch 0 taken 1127 times.
✗ Branch 1 not taken.
|
1127 | schema_name_ptr->c_ptr_safe(); |
| 9080 | |||
| 9081 | // Check if schema is hidden. | ||
| 9082 |
1/2✓ Branch 0 taken 1127 times.
✗ Branch 1 not taken.
|
1127 | THD *thd = current_thd; |
| 9083 |
2/4✓ Branch 0 taken 1127 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1127 times.
|
1127 | if (is_hidden_by_ndb(thd, schema_name_ptr, nullptr)) return 0; |
| 9084 | |||
| 9085 | // Skip INFORMATION_SCHEMA database | ||
| 9086 |
3/4✓ Branch 0 taken 1127 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1125 times.
|
1127 | if (is_infoschema_db(schema_name_ptr->ptr())) return 1; |
| 9087 | |||
| 9088 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1125 times.
|
1125 | if (lower_case_table_names == 2) { |
| 9089 | /* | ||
| 9090 | ACL code assumes that in l-c-t-n > 0 modes schema name passed to it | ||
| 9091 | is in lower case. | ||
| 9092 | */ | ||
| 9093 | ✗ | my_casedn_str(files_charset_info, schema_name_ptr->ptr()); | |
| 9094 | } | ||
| 9095 | |||
| 9096 | // Check access | ||
| 9097 |
3/4✓ Branch 0 taken 1125 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 1122 times.
|
1125 | if (check_access(thd, EVENT_ACL, schema_name_ptr->ptr(), nullptr, nullptr, |
| 9098 | false, true)) { | ||
| 9099 | 3 | return 0; | |
| 9100 | } | ||
| 9101 | |||
| 9102 | 1122 | return 1; | |
| 9103 | 1128 | } | |
| 9104 | |||
| 9105 | /** | ||
| 9106 | @brief | ||
| 9107 | INFORMATION_SCHEMA picks metadata from DD using system views. | ||
| 9108 | In order for INFORMATION_SCHEMA to skip listing resource groups for which | ||
| 9109 | the user does not have rights, the following internal functions are used. | ||
| 9110 | |||
| 9111 | Syntax: | ||
| 9112 | int CAN_ACCCESS_RESOURCE_GROUP(resource_group_name); | ||
| 9113 | |||
| 9114 | @returns, | ||
| 9115 | 1 - If current user has access. | ||
| 9116 | 0 - If not. | ||
| 9117 | */ | ||
| 9118 | |||
| 9119 | 26 | longlong Item_func_can_access_resource_group::val_int() { | |
| 9120 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | DBUG_TRACE; |
| 9121 | |||
| 9122 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | auto mgr_ptr = resourcegroups::Resource_group_mgr::instance(); |
| 9123 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
|
26 | if (!mgr_ptr->resource_group_support()) { |
| 9124 | ✗ | null_value = true; | |
| 9125 | ✗ | return false; | |
| 9126 | } | ||
| 9127 | |||
| 9128 | // Read resource group name. | ||
| 9129 | 26 | String res_grp_name; | |
| 9130 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | String *res_grp_name_ptr = args[0]->val_str(&res_grp_name); |
| 9131 | |||
| 9132 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
|
26 | if (res_grp_name_ptr == nullptr) { |
| 9133 | ✗ | null_value = true; | |
| 9134 | ✗ | return false; | |
| 9135 | } | ||
| 9136 | |||
| 9137 | // Make sure we have safe string to access. | ||
| 9138 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | res_grp_name_ptr->c_ptr_safe(); |
| 9139 | |||
| 9140 | 26 | MDL_ticket *ticket = nullptr; | |
| 9141 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
|
26 | if (mgr_ptr->acquire_shared_mdl_for_resource_group( |
| 9142 |
3/6✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 26 times.
✗ Branch 5 not taken.
|
26 | current_thd, res_grp_name_ptr->c_ptr(), MDL_EXPLICIT, &ticket, false)) |
| 9143 | ✗ | return false; | |
| 9144 | |||
| 9145 |
3/6✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 26 times.
✗ Branch 5 not taken.
|
26 | auto res_grp_ptr = mgr_ptr->get_resource_group(res_grp_name_ptr->c_ptr()); |
| 9146 | 26 | longlong result = true; | |
| 9147 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | if (res_grp_ptr != nullptr) { |
| 9148 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | Security_context *sctx = current_thd->security_context(); |
| 9149 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 16 times.
|
26 | if (res_grp_ptr->type() == resourcegroups::Type::SYSTEM_RESOURCE_GROUP) { |
| 9150 |
8/16✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 4 times.
✓ Branch 6 taken 10 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 10 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4 times.
✓ Branch 11 taken 6 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
|
16 | if (!(sctx->check_access(SUPER_ACL) || |
| 9151 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | sctx->has_global_grant(STRING_WITH_LEN("RESOURCE_GROUP_ADMIN")) |
| 9152 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
|
6 | .first)) |
| 9153 | 4 | result = false; | |
| 9154 | } else { | ||
| 9155 |
8/16✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 13 times.
✓ Branch 6 taken 16 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 16 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✓ Branch 11 taken 15 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
|
19 | if (!(sctx->check_access(SUPER_ACL) || |
| 9156 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | sctx->has_global_grant(STRING_WITH_LEN("RESOURCE_GROUP_ADMIN")) |
| 9157 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
|
3 | .first || |
| 9158 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | sctx->has_global_grant(STRING_WITH_LEN("RESOURCE_GROUP_USER")) |
| 9159 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | .first)) |
| 9160 | 1 | result = false; | |
| 9161 | } | ||
| 9162 | } | ||
| 9163 |
2/4✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
|
26 | mgr_ptr->release_shared_mdl_for_resource_group(current_thd, ticket); |
| 9164 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | return res_grp_ptr != nullptr ? result : false; |
| 9165 | 26 | } | |
| 9166 | |||
| 9167 | /** | ||
| 9168 | @brief | ||
| 9169 | INFORMATION_SCHEMA picks metadata from DD using system views. | ||
| 9170 | In order for INFORMATION_SCHEMA to skip listing column for which | ||
| 9171 | the user does not have rights, the following UDF's is used. | ||
| 9172 | |||
| 9173 | Syntax: | ||
| 9174 | int CAN_ACCCESS_COLUMN(schema_name, | ||
| 9175 | table_name, | ||
| 9176 | field_name); | ||
| 9177 | |||
| 9178 | @returns, | ||
| 9179 | 1 - If current user has access. | ||
| 9180 | 0 - If not. | ||
| 9181 | */ | ||
| 9182 | 19974077 | longlong Item_func_can_access_column::val_int() { | |
| 9183 |
1/2✓ Branch 0 taken 19974078 times.
✗ Branch 1 not taken.
|
19974077 | DBUG_TRACE; |
| 9184 | |||
| 9185 | // Read schema_name, table_name | ||
| 9186 | 19974078 | String schema_name; | |
| 9187 |
1/2✓ Branch 0 taken 19974078 times.
✗ Branch 1 not taken.
|
19974078 | String *schema_name_ptr = args[0]->val_str(&schema_name); |
| 9188 | 19974078 | String table_name; | |
| 9189 |
1/2✓ Branch 0 taken 19974078 times.
✗ Branch 1 not taken.
|
19974078 | String *table_name_ptr = args[1]->val_str(&table_name); |
| 9190 |
3/4✓ Branch 0 taken 19974077 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 19974077 times.
|
19974078 | if (schema_name_ptr == nullptr || table_name_ptr == nullptr) { |
| 9191 | 1 | null_value = true; | |
| 9192 | 1 | return 0; | |
| 9193 | } | ||
| 9194 | |||
| 9195 | // Make sure we have safe string to access. | ||
| 9196 |
1/2✓ Branch 0 taken 19974077 times.
✗ Branch 1 not taken.
|
19974077 | schema_name_ptr->c_ptr_safe(); |
| 9197 |
1/2✓ Branch 0 taken 19974077 times.
✗ Branch 1 not taken.
|
19974077 | table_name_ptr->c_ptr_safe(); |
| 9198 | |||
| 9199 | // Check if table is hidden. | ||
| 9200 |
1/2✓ Branch 0 taken 19974077 times.
✗ Branch 1 not taken.
|
19974077 | THD *thd = current_thd; |
| 9201 |
2/4✓ Branch 0 taken 19974077 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19974077 times.
|
19974077 | if (is_hidden_by_ndb(thd, schema_name_ptr, table_name_ptr)) return 0; |
| 9202 | |||
| 9203 | // Read column_name. | ||
| 9204 | 19974077 | String column_name; | |
| 9205 |
1/2✓ Branch 0 taken 19974077 times.
✗ Branch 1 not taken.
|
19974077 | String *column_name_ptr = args[2]->val_str(&column_name); |
| 9206 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19974077 times.
|
19974077 | if (column_name_ptr == nullptr) { |
| 9207 | ✗ | null_value = true; | |
| 9208 | ✗ | return 0; | |
| 9209 | } | ||
| 9210 | |||
| 9211 | // Make sure we have safe string to access. | ||
| 9212 |
1/2✓ Branch 0 taken 19974077 times.
✗ Branch 1 not taken.
|
19974077 | column_name_ptr->c_ptr_safe(); |
| 9213 | |||
| 9214 | // Skip INFORMATION_SCHEMA database | ||
| 9215 |
3/4✓ Branch 0 taken 19974077 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20655 times.
✓ Branch 3 taken 19953422 times.
|
19974077 | if (is_infoschema_db(schema_name_ptr->ptr())) return 1; |
| 9216 | |||
| 9217 | // Check access | ||
| 9218 |
1/2✓ Branch 0 taken 19953422 times.
✗ Branch 1 not taken.
|
19953422 | GRANT_INFO grant_info; |
| 9219 | |||
| 9220 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19953422 times.
|
19953422 | if (lower_case_table_names == 2) { |
| 9221 | /* | ||
| 9222 | ACL code assumes that in l-c-t-n > 0 modes schema and table names | ||
| 9223 | passed to it are in lower case. | ||
| 9224 | */ | ||
| 9225 | ✗ | my_casedn_str(files_charset_info, schema_name_ptr->ptr()); | |
| 9226 | ✗ | my_casedn_str(files_charset_info, table_name_ptr->ptr()); | |
| 9227 | } | ||
| 9228 | |||
| 9229 |
2/4✓ Branch 0 taken 19953421 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19953421 times.
|
19953422 | if (check_access(thd, SELECT_ACL, schema_name_ptr->ptr(), |
| 9230 | &grant_info.privilege, nullptr, false, true)) | ||
| 9231 | ✗ | return 0; | |
| 9232 | |||
| 9233 | uint col_access = | ||
| 9234 |
1/2✓ Branch 0 taken 19953422 times.
✗ Branch 1 not taken.
|
19953422 | get_column_grant(thd, &grant_info, schema_name_ptr->ptr(), |
| 9235 | 19953421 | table_name_ptr->ptr(), column_name_ptr->ptr()) & | |
| 9236 | 19953422 | COL_ACLS; | |
| 9237 |
2/2✓ Branch 0 taken 231 times.
✓ Branch 1 taken 19953191 times.
|
19953422 | if (!col_access) { |
| 9238 | 231 | return 0; | |
| 9239 | } | ||
| 9240 | |||
| 9241 | 19953191 | return 1; | |
| 9242 | 19974078 | } | |
| 9243 | |||
| 9244 | /** | ||
| 9245 | @brief | ||
| 9246 | INFORMATION_SCHEMA picks metadata from DD using system views. | ||
| 9247 | In order for INFORMATION_SCHEMA to skip listing view definition | ||
| 9248 | for the user without rights, the following UDF's is used. | ||
| 9249 | |||
| 9250 | Syntax: | ||
| 9251 | int CAN_ACCESS_VIEW(schema_name, view_name, definer, options); | ||
| 9252 | |||
| 9253 | @returns, | ||
| 9254 | 1 - If current user has access. | ||
| 9255 | 0 - If not. | ||
| 9256 | */ | ||
| 9257 | 554 | longlong Item_func_can_access_view::val_int() { | |
| 9258 |
1/2✓ Branch 0 taken 554 times.
✗ Branch 1 not taken.
|
554 | DBUG_TRACE; |
| 9259 | |||
| 9260 | // Read schema_name, table_name | ||
| 9261 | 554 | String schema_name; | |
| 9262 | 554 | String table_name; | |
| 9263 | 554 | String definer; | |
| 9264 | 554 | String options; | |
| 9265 |
1/2✓ Branch 0 taken 554 times.
✗ Branch 1 not taken.
|
554 | String *schema_name_ptr = args[0]->val_str(&schema_name); |
| 9266 |
1/2✓ Branch 0 taken 554 times.
✗ Branch 1 not taken.
|
554 | String *table_name_ptr = args[1]->val_str(&table_name); |
| 9267 |
1/2✓ Branch 0 taken 554 times.
✗ Branch 1 not taken.
|
554 | String *definer_ptr = args[2]->val_str(&definer); |
| 9268 |
1/2✓ Branch 0 taken 554 times.
✗ Branch 1 not taken.
|
554 | String *options_ptr = args[3]->val_str(&options); |
| 9269 |
4/6✓ Branch 0 taken 553 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 553 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 553 times.
✗ Branch 5 not taken.
|
554 | if (schema_name_ptr == nullptr || table_name_ptr == nullptr || |
| 9270 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 553 times.
|
553 | definer_ptr == nullptr || options_ptr == nullptr) { |
| 9271 | 1 | null_value = true; | |
| 9272 | 1 | return 0; | |
| 9273 | } | ||
| 9274 | |||
| 9275 | // Make strings safe. | ||
| 9276 |
1/2✓ Branch 0 taken 553 times.
✗ Branch 1 not taken.
|
553 | schema_name_ptr->c_ptr_safe(); |
| 9277 |
1/2✓ Branch 0 taken 553 times.
✗ Branch 1 not taken.
|
553 | table_name_ptr->c_ptr_safe(); |
| 9278 |
1/2✓ Branch 0 taken 553 times.
✗ Branch 1 not taken.
|
553 | definer_ptr->c_ptr_safe(); |
| 9279 |
1/2✓ Branch 0 taken 553 times.
✗ Branch 1 not taken.
|
553 | options_ptr->c_ptr_safe(); |
| 9280 | |||
| 9281 | // Skip INFORMATION_SCHEMA database | ||
| 9282 |
4/6✓ Branch 0 taken 553 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 553 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 314 times.
✓ Branch 5 taken 239 times.
|
1106 | if (is_infoschema_db(schema_name_ptr->ptr()) || |
| 9283 |
3/4✓ Branch 0 taken 553 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 314 times.
✓ Branch 3 taken 239 times.
|
553 | !my_strcasecmp(system_charset_info, schema_name_ptr->ptr(), "sys")) |
| 9284 | 314 | return 1; | |
| 9285 | |||
| 9286 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 239 times.
|
239 | if (lower_case_table_names == 2) { |
| 9287 | /* | ||
| 9288 | ACL code assumes that in l-c-t-n > 0 modes schema and table names | ||
| 9289 | passed to it are in lower case. Although for view names lowercasing | ||
| 9290 | is not strictly necessary until bug#20356 is fixed we still do it | ||
| 9291 | to be consistent with CAN_ACCESS_TABLE(). | ||
| 9292 | */ | ||
| 9293 | ✗ | schema_name_ptr->length( | |
| 9294 | ✗ | my_casedn_str(files_charset_info, schema_name_ptr->ptr())); | |
| 9295 | ✗ | table_name_ptr->length( | |
| 9296 | ✗ | my_casedn_str(files_charset_info, table_name_ptr->ptr())); | |
| 9297 | } | ||
| 9298 | |||
| 9299 | // Check if view is valid. If view is invalid then push invalid view | ||
| 9300 | // warning. | ||
| 9301 | 239 | bool is_view_valid = true; | |
| 9302 | std::unique_ptr<dd::Properties> view_options( | ||
| 9303 |
3/6✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 239 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 239 times.
✗ Branch 5 not taken.
|
239 | dd::Properties::parse_properties(options_ptr->c_ptr_safe())); |
| 9304 | |||
| 9305 | // Warn if the property string is corrupt. | ||
| 9306 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 239 times.
|
239 | if (!view_options.get()) { |
| 9307 | ✗ | LogErr(WARNING_LEVEL, ER_WARN_PROPERTY_STRING_PARSE_FAILED, | |
| 9308 | options_ptr->c_ptr_safe()); | ||
| 9309 | ✗ | assert(false); | |
| 9310 | return 0; | ||
| 9311 | } | ||
| 9312 | |||
| 9313 |
3/6✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 239 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 239 times.
|
239 | if (view_options->get("view_valid", &is_view_valid)) return 0; |
| 9314 | |||
| 9315 | // Show warning/error if view is invalid. | ||
| 9316 |
1/2✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
|
239 | THD *thd = current_thd; |
| 9317 |
1/2✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
|
239 | const String db_str(schema_name_ptr->c_ptr_safe(), system_charset_info); |
| 9318 |
1/2✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
|
239 | const String name_str(table_name_ptr->c_ptr_safe(), system_charset_info); |
| 9319 |
4/4✓ Branch 0 taken 66 times.
✓ Branch 1 taken 173 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 230 times.
|
305 | if (!is_view_valid && |
| 9320 |
3/4✓ Branch 0 taken 66 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 57 times.
|
66 | !thd->lex->m_IS_table_stats.check_error_for_key(db_str, name_str)) { |
| 9321 | std::string err_message = push_view_warning_or_error( | ||
| 9322 |
2/4✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
|
9 | current_thd, schema_name_ptr->ptr(), table_name_ptr->ptr()); |
| 9323 | |||
| 9324 | /* | ||
| 9325 | Cache the error message, so that we do not show the same error multiple | ||
| 9326 | times. | ||
| 9327 | */ | ||
| 9328 |
2/4✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
|
9 | thd->lex->m_IS_table_stats.store_error_message(db_str, name_str, nullptr, |
| 9329 | err_message.c_str()); | ||
| 9330 | 9 | } | |
| 9331 | |||
| 9332 | // | ||
| 9333 | // Check if definer user/host has access. | ||
| 9334 | // | ||
| 9335 | |||
| 9336 | 239 | Security_context *sctx = thd->security_context(); | |
| 9337 | |||
| 9338 | // NOTE: this is a copy/paste from sp_head::set_definer(). | ||
| 9339 | |||
| 9340 | char user_name_holder[USERNAME_LENGTH + 1]; | ||
| 9341 | 239 | LEX_STRING user_name = {user_name_holder, USERNAME_LENGTH}; | |
| 9342 | |||
| 9343 | char host_name_holder[HOSTNAME_LENGTH + 1]; | ||
| 9344 | 239 | LEX_STRING host_name = {host_name_holder, HOSTNAME_LENGTH}; | |
| 9345 | |||
| 9346 |
1/2✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
|
239 | parse_user(definer_ptr->ptr(), definer_ptr->length(), user_name.str, |
| 9347 | &user_name.length, host_name.str, &host_name.length); | ||
| 9348 | |||
| 9349 |
1/2✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
|
239 | std::string definer_user(user_name.str, user_name.length); |
| 9350 |
1/2✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
|
239 | std::string definer_host(host_name.str, host_name.length); |
| 9351 | |||
| 9352 |
5/6✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 211 times.
✓ Branch 3 taken 28 times.
✓ Branch 4 taken 211 times.
✓ Branch 5 taken 28 times.
|
450 | if (!strcmp(definer_user.c_str(), sctx->priv_user().str) && |
| 9353 |
3/6✓ Branch 0 taken 211 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 211 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 211 times.
✗ Branch 5 not taken.
|
211 | !my_strcasecmp(system_charset_info, definer_host.c_str(), |
| 9354 | sctx->priv_host().str)) | ||
| 9355 | 211 | return 1; | |
| 9356 | |||
| 9357 | // | ||
| 9358 | // Check for ACL's | ||
| 9359 | // | ||
| 9360 |
1/2✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
|
28 | TABLE_LIST table_list; |
| 9361 | 28 | table_list.db = schema_name_ptr->ptr(); | |
| 9362 | 28 | table_list.db_length = schema_name_ptr->length(); | |
| 9363 | 28 | table_list.table_name = table_name_ptr->ptr(); | |
| 9364 | 28 | table_list.table_name_length = table_name_ptr->length(); | |
| 9365 | |||
| 9366 |
3/4✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 16 times.
|
28 | if (!check_table_access(thd, (SHOW_VIEW_ACL | SELECT_ACL), &table_list, false, |
| 9367 | 1, true)) | ||
| 9368 | 12 | return 1; | |
| 9369 | |||
| 9370 | 16 | return 0; | |
| 9371 | 554 | } | |
| 9372 | |||
| 9373 | /** | ||
| 9374 | Skip hidden tables, columns, indexes and index elements. Additionally, | ||
| 9375 | skip generated invisible primary key(GIPK) and key column when system | ||
| 9376 | variable show_gipk_in_create_table_and_information_schema is set to | ||
| 9377 | OFF. | ||
| 9378 | Do *not* skip hidden tables, columns, indexes and index elements, | ||
| 9379 | when SHOW EXTENDED command are run. GIPK and key column are skipped | ||
| 9380 | even for SHOW EXTENED command. | ||
| 9381 | |||
| 9382 | Syntax: | ||
| 9383 | longlong IS_VISIBLE_DD_OBJECT(type_of_hidden_table [, is_object_hidden | ||
| 9384 | [, object_options]]) | ||
| 9385 | |||
| 9386 | @returns, | ||
| 9387 | 1 - If dd object is visible | ||
| 9388 | 0 - If not visible. | ||
| 9389 | */ | ||
| 9390 | 22087056 | longlong Item_func_is_visible_dd_object::val_int() { | |
| 9391 |
1/2✓ Branch 0 taken 22087056 times.
✗ Branch 1 not taken.
|
22087056 | DBUG_TRACE; |
| 9392 | |||
| 9393 |
2/4✓ Branch 0 taken 22087056 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 22087056 times.
✗ Branch 3 not taken.
|
22087056 | assert(arg_count > 0 && arg_count <= 3); |
| 9394 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22087056 times.
|
22087056 | assert(args[0]->null_value == false); |
| 9395 | |||
| 9396 |
4/6✓ Branch 0 taken 22087056 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20096515 times.
✓ Branch 3 taken 1990541 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 20096515 times.
|
22087056 | if (args[0]->null_value || (arg_count >= 2 && args[1]->null_value)) { |
| 9397 | ✗ | null_value = true; | |
| 9398 | ✗ | return false; | |
| 9399 | } | ||
| 9400 | |||
| 9401 | 22087056 | null_value = false; | |
| 9402 |
1/2✓ Branch 0 taken 22087056 times.
✗ Branch 1 not taken.
|
22087056 | THD *thd = current_thd; |
| 9403 | |||
| 9404 | auto table_type = | ||
| 9405 |
1/2✓ Branch 0 taken 22087056 times.
✗ Branch 1 not taken.
|
22087056 | static_cast<dd::Abstract_table::enum_hidden_type>(args[0]->val_int()); |
| 9406 | |||
| 9407 | 22087056 | bool show_table = (table_type == dd::Abstract_table::HT_VISIBLE); | |
| 9408 | |||
| 9409 | // Make I_S.TABLES show the hidden system view 'show_statistics' for | ||
| 9410 | // testing purpose. | ||
| 9411 |
3/4✓ Branch 0 taken 22087056 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 46 times.
✓ Branch 3 taken 22087010 times.
|
22087056 | DBUG_EXECUTE_IF("fetch_system_view_definition", { return 1; }); |
| 9412 | |||
| 9413 |
2/2✓ Branch 0 taken 58 times.
✓ Branch 1 taken 22086952 times.
|
22087010 | if (thd->lex->m_extended_show) |
| 9414 | 58 | show_table = | |
| 9415 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 54 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
58 | show_table || (table_type == dd::Abstract_table::HT_HIDDEN_DDL); |
| 9416 | |||
| 9417 |
6/6✓ Branch 0 taken 20096515 times.
✓ Branch 1 taken 1990495 times.
✓ Branch 2 taken 9863048 times.
✓ Branch 3 taken 10233467 times.
✓ Branch 4 taken 1180497 times.
✓ Branch 5 taken 10673046 times.
|
22087010 | if (arg_count == 1 || show_table == false) return (show_table ? 1 : 0); |
| 9418 | |||
| 9419 | // Skip generated invisible primary key and key columns. | ||
| 9420 |
6/8✓ Branch 0 taken 10233467 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10233467 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8160774 times.
✓ Branch 5 taken 2072693 times.
✓ Branch 6 taken 185 times.
✓ Branch 7 taken 10233282 times.
|
18394241 | if (arg_count == 3 && !args[2]->is_null() && |
| 9421 |
2/2✓ Branch 0 taken 185 times.
✓ Branch 1 taken 8160589 times.
|
8160774 | !thd->variables.show_gipk_in_create_table_and_information_schema) { |
| 9422 | 185 | String options; | |
| 9423 |
1/2✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
|
185 | String *options_ptr = args[2]->val_str(&options); |
| 9424 | |||
| 9425 |
1/2✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
|
185 | if (options_ptr != nullptr) { |
| 9426 | // Read options from properties | ||
| 9427 | std::unique_ptr<dd::Properties> p( | ||
| 9428 |
3/6✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 185 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 185 times.
✗ Branch 5 not taken.
|
185 | dd::Properties::parse_properties(options_ptr->c_ptr_safe())); |
| 9429 | |||
| 9430 |
1/2✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
|
185 | if (p.get()) { |
| 9431 |
4/6✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 185 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 88 times.
✓ Branch 5 taken 97 times.
|
185 | if (p->exists("gipk")) { |
| 9432 | 88 | bool gipk_value = false; | |
| 9433 |
2/4✓ Branch 0 taken 88 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
✗ Branch 3 not taken.
|
88 | p->get("gipk", &gipk_value); |
| 9434 |
1/2✓ Branch 0 taken 88 times.
✗ Branch 1 not taken.
|
88 | if (gipk_value) return 0; |
| 9435 | } | ||
| 9436 | } else { | ||
| 9437 | // Warn if the property string is corrupt. | ||
| 9438 | ✗ | LogErr(WARNING_LEVEL, ER_WARN_PROPERTY_STRING_PARSE_FAILED, | |
| 9439 | options_ptr->c_ptr_safe()); | ||
| 9440 | ✗ | assert(false); | |
| 9441 | } | ||
| 9442 |
2/2✓ Branch 0 taken 97 times.
✓ Branch 1 taken 88 times.
|
185 | } |
| 9443 | /* | ||
| 9444 | Even if object is not a GIPK column/key we still need to check if it is | ||
| 9445 | marked as hidden. | ||
| 9446 | */ | ||
| 9447 |
2/2✓ Branch 0 taken 97 times.
✓ Branch 1 taken 88 times.
|
185 | } |
| 9448 | |||
| 9449 | bool show_non_table_objects; | ||
| 9450 |
2/2✓ Branch 0 taken 46 times.
✓ Branch 1 taken 10233333 times.
|
10233379 | if (thd->lex->m_extended_show) |
| 9451 | 46 | show_non_table_objects = true; | |
| 9452 | else | ||
| 9453 |
1/2✓ Branch 0 taken 10233333 times.
✗ Branch 1 not taken.
|
10233333 | show_non_table_objects = (args[1]->val_bool() == false); |
| 9454 | |||
| 9455 |
2/2✓ Branch 0 taken 8166203 times.
✓ Branch 1 taken 2067176 times.
|
10233379 | return show_non_table_objects ? 1 : 0; |
| 9456 | 22087056 | } | |
| 9457 | |||
| 9458 | /** | ||
| 9459 | Get table statistics from dd::info_schema::get_table_statistics. | ||
| 9460 | |||
| 9461 | @param args List of parameters in following order, | ||
| 9462 | |||
| 9463 | - Schema_name | ||
| 9464 | - Table_name | ||
| 9465 | - Engine_name | ||
| 9466 | - se_private_id | ||
| 9467 | - Hidden_table | ||
| 9468 | - Tablespace_se_private_data | ||
| 9469 | - Table_se_private_data (Used if stype is AUTO_INC) | ||
| 9470 | - Partition name (optional argument). | ||
| 9471 | |||
| 9472 | @param arg_count Number of arguments in 'args' | ||
| 9473 | |||
| 9474 | @param stype Type of statistics that is requested | ||
| 9475 | |||
| 9476 | @param[out] null_value Marked true indicating NULL, if there is no value. | ||
| 9477 | |||
| 9478 | @returns ulonglong representing the statistics requested. | ||
| 9479 | */ | ||
| 9480 | |||
| 9481 | 443446 | static ulonglong get_table_statistics( | |
| 9482 | Item **args, uint arg_count, dd::info_schema::enum_table_stats_type stype, | ||
| 9483 | bool *null_value) { | ||
| 9484 |
1/2✓ Branch 0 taken 443446 times.
✗ Branch 1 not taken.
|
443446 | DBUG_TRACE; |
| 9485 | 443446 | *null_value = false; | |
| 9486 | |||
| 9487 | // Reads arguments | ||
| 9488 | 443446 | String schema_name; | |
| 9489 | 443446 | String table_name; | |
| 9490 | 443446 | String engine_name; | |
| 9491 | 443446 | String ts_se_private_data; | |
| 9492 | 443446 | String tbl_se_private_data; | |
| 9493 | 443446 | String partition_name; | |
| 9494 | 443446 | String *partition_name_ptr = nullptr; | |
| 9495 |
1/2✓ Branch 0 taken 443446 times.
✗ Branch 1 not taken.
|
443446 | String *schema_name_ptr = args[0]->val_str(&schema_name); |
| 9496 |
1/2✓ Branch 0 taken 443446 times.
✗ Branch 1 not taken.
|
443446 | String *table_name_ptr = args[1]->val_str(&table_name); |
| 9497 |
1/2✓ Branch 0 taken 443446 times.
✗ Branch 1 not taken.
|
443446 | String *engine_name_ptr = args[2]->val_str(&engine_name); |
| 9498 |
1/2✓ Branch 0 taken 443446 times.
✗ Branch 1 not taken.
|
443446 | bool skip_hidden_table = args[4]->val_int(); |
| 9499 |
1/2✓ Branch 0 taken 443446 times.
✗ Branch 1 not taken.
|
443446 | String *ts_se_private_data_ptr = args[5]->val_str(&ts_se_private_data); |
| 9500 |
1/2✓ Branch 0 taken 443446 times.
✗ Branch 1 not taken.
|
443446 | ulonglong stat_data = args[6]->val_uint(); |
| 9501 |
1/2✓ Branch 0 taken 443446 times.
✗ Branch 1 not taken.
|
443446 | ulonglong cached_timestamp = args[7]->val_uint(); |
| 9502 | |||
| 9503 | 443446 | String *tbl_se_private_data_ptr = nullptr; | |
| 9504 | |||
| 9505 | /* | ||
| 9506 | The same native function used by I_S.TABLES is used by I_S.PARTITIONS. | ||
| 9507 | We invoke native function with partition name only with I_S.PARTITIONS | ||
| 9508 | as a last argument. So, we check for argument count below, before | ||
| 9509 | reading partition name. | ||
| 9510 | */ | ||
| 9511 |
2/2✓ Branch 0 taken 55381 times.
✓ Branch 1 taken 388065 times.
|
443446 | if (stype == dd::info_schema::enum_table_stats_type::AUTO_INCREMENT) { |
| 9512 |
1/2✓ Branch 0 taken 55381 times.
✗ Branch 1 not taken.
|
55381 | tbl_se_private_data_ptr = args[8]->val_str(&tbl_se_private_data); |
| 9513 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 55381 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
55381 | if (arg_count == 10) partition_name_ptr = args[9]->val_str(&partition_name); |
| 9514 |
2/2✓ Branch 0 taken 337 times.
✓ Branch 1 taken 387728 times.
|
388065 | } else if (arg_count == 9) |
| 9515 |
1/2✓ Branch 0 taken 337 times.
✗ Branch 1 not taken.
|
337 | partition_name_ptr = args[8]->val_str(&partition_name); |
| 9516 | |||
| 9517 |
4/6✓ Branch 0 taken 443438 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 443438 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 443438 times.
✗ Branch 5 not taken.
|
443446 | if (schema_name_ptr == nullptr || table_name_ptr == nullptr || |
| 9518 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 443422 times.
|
443438 | engine_name_ptr == nullptr || skip_hidden_table) { |
| 9519 | 24 | *null_value = true; | |
| 9520 | 24 | return 0; | |
| 9521 | } | ||
| 9522 | |||
| 9523 | // Make sure we have safe string to access. | ||
| 9524 |
1/2✓ Branch 0 taken 443422 times.
✗ Branch 1 not taken.
|
443422 | schema_name_ptr->c_ptr_safe(); |
| 9525 |
1/2✓ Branch 0 taken 443422 times.
✗ Branch 1 not taken.
|
443422 | table_name_ptr->c_ptr_safe(); |
| 9526 |
1/2✓ Branch 0 taken 443422 times.
✗ Branch 1 not taken.
|
443422 | engine_name_ptr->c_ptr_safe(); |
| 9527 | |||
| 9528 | // Do not read dynamic stats for I_S tables. | ||
| 9529 |
3/4✓ Branch 0 taken 443422 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 147391 times.
✓ Branch 3 taken 296031 times.
|
443422 | if (is_infoschema_db(schema_name_ptr->ptr())) return 0; |
| 9530 | |||
| 9531 | // Read the statistic value from cache. | ||
| 9532 |
1/2✓ Branch 0 taken 296031 times.
✗ Branch 1 not taken.
|
296031 | THD *thd = current_thd; |
| 9533 |
1/2✓ Branch 0 taken 296031 times.
✗ Branch 1 not taken.
|
296031 | dd::Object_id se_private_id = (dd::Object_id)args[3]->val_uint(); |
| 9534 |
7/8✓ Branch 0 taken 1055 times.
✓ Branch 1 taken 294976 times.
✓ Branch 2 taken 66072 times.
✓ Branch 3 taken 229959 times.
✓ Branch 4 taken 323 times.
✓ Branch 5 taken 295708 times.
✓ Branch 6 taken 296031 times.
✗ Branch 7 not taken.
|
363481 | ulonglong result = thd->lex->m_IS_table_stats.read_stat( |
| 9535 | thd, *schema_name_ptr, *table_name_ptr, *engine_name_ptr, | ||
| 9536 |
1/2✓ Branch 0 taken 323 times.
✗ Branch 1 not taken.
|
323 | (partition_name_ptr ? partition_name_ptr->c_ptr_safe() : nullptr), |
| 9537 | se_private_id, | ||
| 9538 |
1/2✓ Branch 0 taken 66072 times.
✗ Branch 1 not taken.
|
66072 | (ts_se_private_data_ptr ? ts_se_private_data_ptr->c_ptr_safe() : nullptr), |
| 9539 |
1/2✓ Branch 0 taken 1055 times.
✗ Branch 1 not taken.
|
1055 | (tbl_se_private_data_ptr ? tbl_se_private_data_ptr->c_ptr_safe() |
| 9540 | : nullptr), | ||
| 9541 | stat_data, cached_timestamp, stype); | ||
| 9542 | |||
| 9543 | 296031 | return result; | |
| 9544 | 443446 | } | |
| 9545 | |||
| 9546 | 55753 | longlong Item_func_internal_table_rows::val_int() { | |
| 9547 |
1/2✓ Branch 0 taken 55753 times.
✗ Branch 1 not taken.
|
55753 | DBUG_TRACE; |
| 9548 | |||
| 9549 |
1/2✓ Branch 0 taken 55753 times.
✗ Branch 1 not taken.
|
55753 | ulonglong result = get_table_statistics( |
| 9550 | args, arg_count, dd::info_schema::enum_table_stats_type::TABLE_ROWS, | ||
| 9551 | &null_value); | ||
| 9552 | |||
| 9553 |
4/4✓ Branch 0 taken 55752 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 55750 times.
|
55753 | if (null_value == false && result == (ulonglong)-1) null_value = true; |
| 9554 | |||
| 9555 | 55753 | return result; | |
| 9556 | 55753 | } | |
| 9557 | |||
| 9558 | 55204 | longlong Item_func_internal_avg_row_length::val_int() { | |
| 9559 |
1/2✓ Branch 0 taken 55204 times.
✗ Branch 1 not taken.
|
55204 | DBUG_TRACE; |
| 9560 | |||
| 9561 |
1/2✓ Branch 0 taken 55204 times.
✗ Branch 1 not taken.
|
55204 | ulonglong result = get_table_statistics( |
| 9562 | args, arg_count, | ||
| 9563 | dd::info_schema::enum_table_stats_type::TABLE_AVG_ROW_LENGTH, | ||
| 9564 | &null_value); | ||
| 9565 | 55204 | return result; | |
| 9566 | 55204 | } | |
| 9567 | |||
| 9568 | 55748 | longlong Item_func_internal_data_length::val_int() { | |
| 9569 |
1/2✓ Branch 0 taken 55748 times.
✗ Branch 1 not taken.
|
55748 | DBUG_TRACE; |
| 9570 | |||
| 9571 |
1/2✓ Branch 0 taken 55748 times.
✗ Branch 1 not taken.
|
55748 | ulonglong result = get_table_statistics( |
| 9572 | args, arg_count, dd::info_schema::enum_table_stats_type::DATA_LENGTH, | ||
| 9573 | &null_value); | ||
| 9574 | 55748 | return result; | |
| 9575 | 55748 | } | |
| 9576 | |||
| 9577 | 55208 | longlong Item_func_internal_max_data_length::val_int() { | |
| 9578 |
1/2✓ Branch 0 taken 55208 times.
✗ Branch 1 not taken.
|
55208 | DBUG_TRACE; |
| 9579 | |||
| 9580 |
1/2✓ Branch 0 taken 55208 times.
✗ Branch 1 not taken.
|
55208 | ulonglong result = get_table_statistics( |
| 9581 | args, arg_count, dd::info_schema::enum_table_stats_type::MAX_DATA_LENGTH, | ||
| 9582 | &null_value); | ||
| 9583 | 55208 | return result; | |
| 9584 | 55208 | } | |
| 9585 | |||
| 9586 | 55754 | longlong Item_func_internal_index_length::val_int() { | |
| 9587 |
1/2✓ Branch 0 taken 55754 times.
✗ Branch 1 not taken.
|
55754 | DBUG_TRACE; |
| 9588 | |||
| 9589 |
1/2✓ Branch 0 taken 55754 times.
✗ Branch 1 not taken.
|
55754 | ulonglong result = get_table_statistics( |
| 9590 | args, arg_count, dd::info_schema::enum_table_stats_type::INDEX_LENGTH, | ||
| 9591 | &null_value); | ||
| 9592 | 55754 | return result; | |
| 9593 | 55754 | } | |
| 9594 | |||
| 9595 | 55201 | longlong Item_func_internal_data_free::val_int() { | |
| 9596 |
1/2✓ Branch 0 taken 55201 times.
✗ Branch 1 not taken.
|
55201 | DBUG_TRACE; |
| 9597 | |||
| 9598 |
1/2✓ Branch 0 taken 55201 times.
✗ Branch 1 not taken.
|
55201 | ulonglong result = get_table_statistics( |
| 9599 | args, arg_count, dd::info_schema::enum_table_stats_type::DATA_FREE, | ||
| 9600 | &null_value); | ||
| 9601 | |||
| 9602 |
3/4✓ Branch 0 taken 55200 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 55200 times.
|
55201 | if (null_value == false && result == (ulonglong)-1) null_value = true; |
| 9603 | |||
| 9604 | 55201 | return result; | |
| 9605 | 55201 | } | |
| 9606 | |||
| 9607 | 55381 | longlong Item_func_internal_auto_increment::val_int() { | |
| 9608 |
1/2✓ Branch 0 taken 55381 times.
✗ Branch 1 not taken.
|
55381 | DBUG_TRACE; |
| 9609 | |||
| 9610 |
1/2✓ Branch 0 taken 55381 times.
✗ Branch 1 not taken.
|
55381 | ulonglong result = get_table_statistics( |
| 9611 | args, arg_count, dd::info_schema::enum_table_stats_type::AUTO_INCREMENT, | ||
| 9612 | &null_value); | ||
| 9613 | |||
| 9614 |
4/4✓ Branch 0 taken 55364 times.
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 53061 times.
✓ Branch 3 taken 2303 times.
|
55381 | if (null_value == false && result < (ulonglong)1) null_value = true; |
| 9615 | |||
| 9616 | 55381 | return result; | |
| 9617 | 55381 | } | |
| 9618 | |||
| 9619 | 55197 | longlong Item_func_internal_checksum::val_int() { | |
| 9620 |
1/2✓ Branch 0 taken 55197 times.
✗ Branch 1 not taken.
|
55197 | DBUG_TRACE; |
| 9621 | |||
| 9622 |
1/2✓ Branch 0 taken 55197 times.
✗ Branch 1 not taken.
|
55197 | ulonglong result = get_table_statistics( |
| 9623 | args, arg_count, dd::info_schema::enum_table_stats_type::CHECKSUM, | ||
| 9624 | &null_value); | ||
| 9625 | |||
| 9626 |
4/4✓ Branch 0 taken 55196 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 55193 times.
✓ Branch 3 taken 3 times.
|
55197 | if (null_value == false && result == 0) null_value = true; |
| 9627 | |||
| 9628 | 55197 | return result; | |
| 9629 | 55197 | } | |
| 9630 | |||
| 9631 | /** | ||
| 9632 | @brief | ||
| 9633 | INFORMATION_SCHEMA picks metadata from DD using system views. | ||
| 9634 | INFORMATION_SCHEMA.STATISTICS.COMMENT is used to indicate if the indexes are | ||
| 9635 | disabled by ALTER TABLE ... DISABLE KEYS. This property of table is stored | ||
| 9636 | in mysql.tables.options as 'keys_disabled=0/1/'. This internal function | ||
| 9637 | returns value of option 'keys_disabled' for a given table. | ||
| 9638 | |||
| 9639 | Syntax: | ||
| 9640 | int INTERNAL_KEYS_DISABLED(table_options); | ||
| 9641 | |||
| 9642 | @returns, | ||
| 9643 | 1 - If keys are disabled. | ||
| 9644 | 0 - If not. | ||
| 9645 | */ | ||
| 9646 | 1172 | longlong Item_func_internal_keys_disabled::val_int() { | |
| 9647 |
1/2✓ Branch 0 taken 1172 times.
✗ Branch 1 not taken.
|
1172 | DBUG_TRACE; |
| 9648 | |||
| 9649 | // Read options. | ||
| 9650 | 1172 | String options; | |
| 9651 |
1/2✓ Branch 0 taken 1172 times.
✗ Branch 1 not taken.
|
1172 | String *options_ptr = args[0]->val_str(&options); |
| 9652 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1171 times.
|
1172 | if (options_ptr == nullptr) return 0; |
| 9653 | |||
| 9654 | // Read table option from properties | ||
| 9655 | std::unique_ptr<dd::Properties> p( | ||
| 9656 |
3/6✓ Branch 0 taken 1171 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1171 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1171 times.
✗ Branch 5 not taken.
|
1171 | dd::Properties::parse_properties(options_ptr->c_ptr_safe())); |
| 9657 | |||
| 9658 | // Warn if the property string is corrupt. | ||
| 9659 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1171 times.
|
1171 | if (!p.get()) { |
| 9660 | ✗ | LogErr(WARNING_LEVEL, ER_WARN_PROPERTY_STRING_PARSE_FAILED, | |
| 9661 | options_ptr->c_ptr_safe()); | ||
| 9662 | ✗ | assert(false); | |
| 9663 | return 0; | ||
| 9664 | } | ||
| 9665 | |||
| 9666 | // Read keys_disabled sub type. | ||
| 9667 | 1171 | uint keys_disabled = 0; | |
| 9668 |
2/4✓ Branch 0 taken 1171 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1171 times.
✗ Branch 3 not taken.
|
1171 | p->get("keys_disabled", &keys_disabled); |
| 9669 | |||
| 9670 | 1171 | return keys_disabled; | |
| 9671 | 1172 | } | |
| 9672 | |||
| 9673 | /** | ||
| 9674 | @brief | ||
| 9675 | INFORMATION_SCHEMA picks metadata from DD using system views. | ||
| 9676 | INFORMATION_SCHEMA.STATISTICS.CARDINALITY reads data from SE. | ||
| 9677 | |||
| 9678 | Syntax: | ||
| 9679 | int INTERNAL_INDEX_COLUMN_CARDINALITY( | ||
| 9680 | schema_name, | ||
| 9681 | table_name, | ||
| 9682 | index_name, | ||
| 9683 | column_name, | ||
| 9684 | index_ordinal_position, | ||
| 9685 | column_ordinal_position, | ||
| 9686 | engine, | ||
| 9687 | se_private_id, | ||
| 9688 | is_hidden, | ||
| 9689 | stat_cardinality, | ||
| 9690 | cached_timestamp); | ||
| 9691 | |||
| 9692 | @returns Cardinatily. Or sets null_value to true if cardinality is -1. | ||
| 9693 | */ | ||
| 9694 | 3452 | longlong Item_func_internal_index_column_cardinality::val_int() { | |
| 9695 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | DBUG_TRACE; |
| 9696 | 3452 | null_value = false; | |
| 9697 | |||
| 9698 | // Read arguments | ||
| 9699 | 3452 | String schema_name; | |
| 9700 | 3452 | String table_name; | |
| 9701 | 3452 | String index_name; | |
| 9702 | 3452 | String column_name; | |
| 9703 | 3452 | String engine_name; | |
| 9704 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | String *schema_name_ptr = args[0]->val_str(&schema_name); |
| 9705 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | String *table_name_ptr = args[1]->val_str(&table_name); |
| 9706 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | String *index_name_ptr = args[2]->val_str(&index_name); |
| 9707 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | String *column_name_ptr = args[3]->val_str(&column_name); |
| 9708 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | uint index_ordinal_position = args[4]->val_uint(); |
| 9709 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | uint column_ordinal_position = args[5]->val_uint(); |
| 9710 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | String *engine_name_ptr = args[6]->val_str(&engine_name); |
| 9711 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | dd::Object_id se_private_id = (dd::Object_id)args[7]->val_uint(); |
| 9712 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | bool hidden_index = args[8]->val_int(); |
| 9713 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | ulonglong stat_cardinality = args[9]->val_uint(); |
| 9714 |
1/2✓ Branch 0 taken 3452 times.
✗ Branch 1 not taken.
|
3452 | ulonglong cached_timestamp = args[10]->val_uint(); |
| 9715 | |||
| 9716 | // stat_cardinality and cached_timestamp from mysql.index_stats can be null | ||
| 9717 | // when stat is fetched for 1st time without executing ANALYZE command. | ||
| 9718 |
4/6✓ Branch 0 taken 3451 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 3451 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3451 times.
✗ Branch 5 not taken.
|
3452 | if (schema_name_ptr == nullptr || table_name_ptr == nullptr || |
| 9719 |
2/4✓ Branch 0 taken 3451 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3451 times.
✗ Branch 3 not taken.
|
3451 | index_name_ptr == nullptr || engine_name_ptr == nullptr || |
| 9720 |
1/2✓ Branch 0 taken 3451 times.
✗ Branch 1 not taken.
|
3451 | column_name_ptr == nullptr || args[4]->null_value || |
| 9721 |
4/6✓ Branch 0 taken 3451 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3451 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 3446 times.
|
3451 | args[5]->null_value || args[8]->null_value || hidden_index) { |
| 9722 | 6 | null_value = true; | |
| 9723 | 6 | return 0; | |
| 9724 | } | ||
| 9725 | |||
| 9726 | // Make sure we have safe string to access. | ||
| 9727 |
1/2✓ Branch 0 taken 3446 times.
✗ Branch 1 not taken.
|
3446 | schema_name_ptr->c_ptr_safe(); |
| 9728 |
1/2✓ Branch 0 taken 3446 times.
✗ Branch 1 not taken.
|
3446 | table_name_ptr->c_ptr_safe(); |
| 9729 |
1/2✓ Branch 0 taken 3446 times.
✗ Branch 1 not taken.
|
3446 | index_name_ptr->c_ptr_safe(); |
| 9730 |
1/2✓ Branch 0 taken 3446 times.
✗ Branch 1 not taken.
|
3446 | column_name_ptr->c_ptr_safe(); |
| 9731 |
1/2✓ Branch 0 taken 3446 times.
✗ Branch 1 not taken.
|
3446 | engine_name_ptr->c_ptr_safe(); |
| 9732 | |||
| 9733 | 3446 | ulonglong result = 0; | |
| 9734 |
1/2✓ Branch 0 taken 3446 times.
✗ Branch 1 not taken.
|
3446 | THD *thd = current_thd; |
| 9735 |
1/2✓ Branch 0 taken 3446 times.
✗ Branch 1 not taken.
|
3446 | result = thd->lex->m_IS_table_stats.read_stat( |
| 9736 | thd, *schema_name_ptr, *table_name_ptr, *index_name_ptr, nullptr, | ||
| 9737 | *column_name_ptr, index_ordinal_position - 1, column_ordinal_position - 1, | ||
| 9738 | *engine_name_ptr, se_private_id, nullptr, nullptr, stat_cardinality, | ||
| 9739 | cached_timestamp, | ||
| 9740 | dd::info_schema::enum_table_stats_type::INDEX_COLUMN_CARDINALITY); | ||
| 9741 | |||
| 9742 |
2/2✓ Branch 0 taken 1491 times.
✓ Branch 1 taken 1955 times.
|
3446 | if (result == (ulonglong)-1) null_value = true; |
| 9743 | |||
| 9744 | 3446 | return result; | |
| 9745 | 3452 | } | |
| 9746 | |||
| 9747 | /** | ||
| 9748 | Retrieve tablespace statistics from SE | ||
| 9749 | |||
| 9750 | @param thd The current thread. | ||
| 9751 | |||
| 9752 | @param args List of parameters in following order, | ||
| 9753 | |||
| 9754 | - Tablespace_name | ||
| 9755 | - Engine_name | ||
| 9756 | - Tablespace_se_private_data | ||
| 9757 | |||
| 9758 | @param[out] null_value Marked true indicating NULL, if there is no value. | ||
| 9759 | */ | ||
| 9760 | |||
| 9761 | 491297 | void retrieve_tablespace_statistics(THD *thd, Item **args, bool *null_value) { | |
| 9762 |
1/2✓ Branch 0 taken 491297 times.
✗ Branch 1 not taken.
|
491297 | DBUG_TRACE; |
| 9763 | 491297 | *null_value = false; | |
| 9764 | |||
| 9765 | // Reads arguments | ||
| 9766 | 491297 | String tablespace_name; | |
| 9767 |
1/2✓ Branch 0 taken 491297 times.
✗ Branch 1 not taken.
|
491297 | String *tablespace_name_ptr = args[0]->val_str(&tablespace_name); |
| 9768 | 491297 | String file_name; | |
| 9769 |
1/2✓ Branch 0 taken 491297 times.
✗ Branch 1 not taken.
|
491297 | String *file_name_ptr = args[1]->val_str(&file_name); |
| 9770 | 491297 | String engine_name; | |
| 9771 |
1/2✓ Branch 0 taken 491297 times.
✗ Branch 1 not taken.
|
491297 | String *engine_name_ptr = args[2]->val_str(&engine_name); |
| 9772 | 491297 | String ts_se_private_data; | |
| 9773 |
1/2✓ Branch 0 taken 491297 times.
✗ Branch 1 not taken.
|
491297 | String *ts_se_private_data_ptr = args[3]->val_str(&ts_se_private_data); |
| 9774 | |||
| 9775 |
4/6✓ Branch 0 taken 491287 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 491287 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 491287 times.
|
491297 | if (tablespace_name_ptr == nullptr || file_name_ptr == nullptr || |
| 9776 | engine_name_ptr == nullptr) { | ||
| 9777 | 10 | *null_value = true; | |
| 9778 | 10 | return; | |
| 9779 | } | ||
| 9780 | |||
| 9781 | // Make sure we have safe string to access. | ||
| 9782 |
1/2✓ Branch 0 taken 491287 times.
✗ Branch 1 not taken.
|
491287 | tablespace_name_ptr->c_ptr_safe(); |
| 9783 |
1/2✓ Branch 0 taken 491287 times.
✗ Branch 1 not taken.
|
491287 | file_name_ptr->c_ptr_safe(); |
| 9784 |
1/2✓ Branch 0 taken 491287 times.
✗ Branch 1 not taken.
|
491287 | engine_name_ptr->c_ptr_safe(); |
| 9785 | |||
| 9786 | // Read the statistic value from cache. | ||
| 9787 |
4/6✓ Branch 0 taken 491287 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 491287 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 332 times.
✓ Branch 5 taken 490955 times.
|
982574 | if (thd->lex->m_IS_tablespace_stats.read_stat( |
| 9788 | thd, *tablespace_name_ptr, *file_name_ptr, *engine_name_ptr, | ||
| 9789 |
1/2✓ Branch 0 taken 491287 times.
✗ Branch 1 not taken.
|
491287 | (ts_se_private_data_ptr ? ts_se_private_data_ptr->c_ptr_safe() |
| 9790 | : nullptr))) | ||
| 9791 | 332 | *null_value = true; | |
| 9792 |
10/10✓ Branch 0 taken 491287 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 491287 times.
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 491287 times.
✓ Branch 5 taken 10 times.
✓ Branch 6 taken 491287 times.
✓ Branch 7 taken 10 times.
✓ Branch 8 taken 491287 times.
✓ Branch 9 taken 10 times.
|
491337 | } |
| 9793 | |||
| 9794 | 14971 | longlong Item_func_internal_tablespace_id::val_int() { | |
| 9795 |
1/2✓ Branch 0 taken 14971 times.
✗ Branch 1 not taken.
|
14971 | DBUG_TRACE; |
| 9796 | 14971 | ulonglong result = -1; | |
| 9797 | |||
| 9798 |
1/2✓ Branch 0 taken 14971 times.
✗ Branch 1 not taken.
|
14971 | THD *thd = current_thd; |
| 9799 |
1/2✓ Branch 0 taken 14971 times.
✗ Branch 1 not taken.
|
14971 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9800 |
2/2✓ Branch 0 taken 14639 times.
✓ Branch 1 taken 332 times.
|
14971 | if (null_value == false) { |
| 9801 |
1/2✓ Branch 0 taken 14639 times.
✗ Branch 1 not taken.
|
14639 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9802 | dd::info_schema::enum_tablespace_stats_type::TS_ID, &result); | ||
| 9803 | 14639 | return result; | |
| 9804 | } | ||
| 9805 | |||
| 9806 | 332 | return result; | |
| 9807 | 14971 | } | |
| 9808 | |||
| 9809 | 2 | longlong Item_func_internal_tablespace_logfile_group_number::val_int() { | |
| 9810 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | DBUG_TRACE; |
| 9811 | 2 | ulonglong result = -1; | |
| 9812 | |||
| 9813 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | THD *thd = current_thd; |
| 9814 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9815 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | if (null_value == false) { |
| 9816 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9817 | dd::info_schema::enum_tablespace_stats_type::TS_LOGFILE_GROUP_NUMBER, | ||
| 9818 | &result); | ||
| 9819 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | if (result == (ulonglong)-1) null_value = true; |
| 9820 | |||
| 9821 | 2 | return result; | |
| 9822 | } | ||
| 9823 | |||
| 9824 | ✗ | return result; | |
| 9825 | 2 | } | |
| 9826 | |||
| 9827 | 11 | longlong Item_func_internal_tablespace_free_extents::val_int() { | |
| 9828 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | DBUG_TRACE; |
| 9829 | 11 | ulonglong result = -1; | |
| 9830 | |||
| 9831 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | THD *thd = current_thd; |
| 9832 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9833 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 1 times.
|
11 | if (null_value == false) { |
| 9834 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9835 | dd::info_schema::enum_tablespace_stats_type::TS_FREE_EXTENTS, &result); | ||
| 9836 | 10 | return result; | |
| 9837 | } | ||
| 9838 | |||
| 9839 | 1 | return result; | |
| 9840 | 11 | } | |
| 9841 | |||
| 9842 | 11 | longlong Item_func_internal_tablespace_total_extents::val_int() { | |
| 9843 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | DBUG_TRACE; |
| 9844 | 11 | ulonglong result = -1; | |
| 9845 | |||
| 9846 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | THD *thd = current_thd; |
| 9847 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9848 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 1 times.
|
11 | if (null_value == false) { |
| 9849 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9850 | dd::info_schema::enum_tablespace_stats_type::TS_TOTAL_EXTENTS, &result); | ||
| 9851 | 10 | return result; | |
| 9852 | } | ||
| 9853 | |||
| 9854 | 1 | return result; | |
| 9855 | 11 | } | |
| 9856 | |||
| 9857 | 11 | longlong Item_func_internal_tablespace_extent_size::val_int() { | |
| 9858 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | DBUG_TRACE; |
| 9859 | 11 | ulonglong result = -1; | |
| 9860 | |||
| 9861 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | THD *thd = current_thd; |
| 9862 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9863 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 1 times.
|
11 | if (null_value == false) { |
| 9864 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9865 | dd::info_schema::enum_tablespace_stats_type::TS_EXTENT_SIZE, &result); | ||
| 9866 | 10 | return result; | |
| 9867 | } | ||
| 9868 | |||
| 9869 | 1 | return result; | |
| 9870 | 11 | } | |
| 9871 | |||
| 9872 | 9 | longlong Item_func_internal_tablespace_initial_size::val_int() { | |
| 9873 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | DBUG_TRACE; |
| 9874 | 9 | ulonglong result = -1; | |
| 9875 | |||
| 9876 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | THD *thd = current_thd; |
| 9877 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9878 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 1 times.
|
9 | if (null_value == false) { |
| 9879 |
1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
|
8 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9880 | dd::info_schema::enum_tablespace_stats_type::TS_INITIAL_SIZE, &result); | ||
| 9881 | 8 | return result; | |
| 9882 | } | ||
| 9883 | |||
| 9884 | 1 | return result; | |
| 9885 | 9 | } | |
| 9886 | |||
| 9887 | 11 | longlong Item_func_internal_tablespace_maximum_size::val_int() { | |
| 9888 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | DBUG_TRACE; |
| 9889 | 11 | ulonglong result = -1; | |
| 9890 | |||
| 9891 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | THD *thd = current_thd; |
| 9892 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9893 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 1 times.
|
11 | if (null_value == false) { |
| 9894 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9895 | dd::info_schema::enum_tablespace_stats_type::TS_MAXIMUM_SIZE, &result); | ||
| 9896 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 1 times.
|
10 | if (result == (ulonglong)-1) null_value = true; |
| 9897 | |||
| 9898 | 10 | return result; | |
| 9899 | } | ||
| 9900 | |||
| 9901 | 1 | return result; | |
| 9902 | 11 | } | |
| 9903 | |||
| 9904 | 9 | longlong Item_func_internal_tablespace_autoextend_size::val_int() { | |
| 9905 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | DBUG_TRACE; |
| 9906 | 9 | ulonglong result = -1; | |
| 9907 | |||
| 9908 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | THD *thd = current_thd; |
| 9909 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9910 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 1 times.
|
9 | if (null_value == false) { |
| 9911 |
1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
|
8 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9912 | dd::info_schema::enum_tablespace_stats_type::TS_AUTOEXTEND_SIZE, | ||
| 9913 | &result); | ||
| 9914 | 8 | return result; | |
| 9915 | } | ||
| 9916 | |||
| 9917 | 1 | return result; | |
| 9918 | 9 | } | |
| 9919 | |||
| 9920 | 2 | longlong Item_func_internal_tablespace_version::val_int() { | |
| 9921 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | DBUG_TRACE; |
| 9922 | 2 | ulonglong result = -1; | |
| 9923 | |||
| 9924 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | THD *thd = current_thd; |
| 9925 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9926 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | if (null_value == false) { |
| 9927 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9928 | dd::info_schema::enum_tablespace_stats_type::TS_VERSION, &result); | ||
| 9929 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | if (result == (ulonglong)-1) null_value = true; |
| 9930 | |||
| 9931 | 2 | return result; | |
| 9932 | } | ||
| 9933 | |||
| 9934 | ✗ | return result; | |
| 9935 | 2 | } | |
| 9936 | |||
| 9937 | 11 | longlong Item_func_internal_tablespace_data_free::val_int() { | |
| 9938 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | DBUG_TRACE; |
| 9939 | 11 | ulonglong result = -1; | |
| 9940 | |||
| 9941 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | THD *thd = current_thd; |
| 9942 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | retrieve_tablespace_statistics(thd, args, &null_value); |
| 9943 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 1 times.
|
11 | if (null_value == false) { |
| 9944 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | thd->lex->m_IS_tablespace_stats.get_stat( |
| 9945 | dd::info_schema::enum_tablespace_stats_type::TS_DATA_FREE, &result); | ||
| 9946 | 10 | return result; | |
| 9947 | } | ||
| 9948 | |||
| 9949 | 1 | return result; | |
| 9950 | 11 | } | |
| 9951 | |||
| 9952 | 6276 | Item_func_version::Item_func_version(const POS &pos) | |
| 9953 | 12552 | : Item_static_string_func(pos, NAME_STRING("version()"), server_version, | |
| 9954 | strlen(server_version), system_charset_info, | ||
| 9955 |
1/2✓ Branch 0 taken 6276 times.
✗ Branch 1 not taken.
|
6276 | DERIVATION_SYSCONST) {} |
| 9956 | |||
| 9957 | /* | ||
| 9958 | Syntax: | ||
| 9959 | string get_dd_char_length() | ||
| 9960 | */ | ||
| 9961 | 16067029 | longlong Item_func_internal_dd_char_length::val_int() { | |
| 9962 |
1/2✓ Branch 0 taken 16067029 times.
✗ Branch 1 not taken.
|
16067029 | DBUG_TRACE; |
| 9963 | 16067029 | null_value = false; | |
| 9964 | |||
| 9965 |
1/2✓ Branch 0 taken 16067029 times.
✗ Branch 1 not taken.
|
16067029 | dd::enum_column_types col_type = (dd::enum_column_types)args[0]->val_int(); |
| 9966 |
1/2✓ Branch 0 taken 16067029 times.
✗ Branch 1 not taken.
|
16067029 | uint field_length = args[1]->val_int(); |
| 9967 | 16067029 | String cs_name; | |
| 9968 |
1/2✓ Branch 0 taken 16067029 times.
✗ Branch 1 not taken.
|
16067029 | String *cs_name_ptr = args[2]->val_str(&cs_name); |
| 9969 |
1/2✓ Branch 0 taken 16067029 times.
✗ Branch 1 not taken.
|
16067029 | uint flag = args[3]->val_int(); |
| 9970 | |||
| 9971 | // Stop if we found a NULL argument. | ||
| 9972 |
4/6✓ Branch 0 taken 15619530 times.
✓ Branch 1 taken 447499 times.
✓ Branch 2 taken 15619530 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15619530 times.
✗ Branch 5 not taken.
|
16067029 | if (args[0]->null_value || args[1]->null_value || cs_name_ptr == nullptr || |
| 9973 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15619530 times.
|
15619530 | args[3]->null_value) { |
| 9974 | 447499 | null_value = true; | |
| 9975 | 447499 | return 0; | |
| 9976 | } | ||
| 9977 | |||
| 9978 | // Read character set. | ||
| 9979 |
2/4✓ Branch 0 taken 15619530 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15619530 times.
✗ Branch 3 not taken.
|
15619530 | CHARSET_INFO *cs = get_charset_by_name(cs_name_ptr->c_ptr_safe(), MYF(0)); |
| 9980 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15619530 times.
|
15619530 | if (!cs) { |
| 9981 | ✗ | null_value = true; | |
| 9982 | ✗ | return 0; | |
| 9983 | } | ||
| 9984 | |||
| 9985 | // Check data types for getting info | ||
| 9986 |
1/2✓ Branch 0 taken 15619530 times.
✗ Branch 1 not taken.
|
15619530 | enum_field_types field_type = dd_get_old_field_type(col_type); |
| 9987 | 15619530 | bool blob_flag = is_blob(field_type); | |
| 9988 |
6/6✓ Branch 0 taken 13579214 times.
✓ Branch 1 taken 2040316 times.
✓ Branch 2 taken 10545216 times.
✓ Branch 3 taken 3033998 times.
✓ Branch 4 taken 10346064 times.
✓ Branch 5 taken 199152 times.
|
15619530 | if (!blob_flag && field_type != MYSQL_TYPE_ENUM && |
| 9989 |
2/2✓ Branch 0 taken 8936699 times.
✓ Branch 1 taken 1409365 times.
|
10346064 | field_type != MYSQL_TYPE_SET && |
| 9990 |
2/2✓ Branch 0 taken 5502739 times.
✓ Branch 1 taken 3433960 times.
|
8936699 | field_type != MYSQL_TYPE_VARCHAR && // For varbinary type |
| 9991 | field_type != MYSQL_TYPE_STRING) // For binary type | ||
| 9992 | { | ||
| 9993 | 5502739 | null_value = true; | |
| 9994 | 5502739 | return 0; | |
| 9995 | } | ||
| 9996 | |||
| 9997 |
2/4✓ Branch 0 taken 10116791 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10116791 times.
✗ Branch 3 not taken.
|
20233582 | std::ostringstream oss(""); |
| 9998 |
5/6✓ Branch 0 taken 1790324 times.
✓ Branch 1 taken 140 times.
✓ Branch 2 taken 199076 times.
✓ Branch 3 taken 50776 times.
✓ Branch 4 taken 8076475 times.
✗ Branch 5 not taken.
|
10116791 | switch (field_type) { |
| 9999 | 1790324 | case MYSQL_TYPE_BLOB: | |
| 10000 | 1790324 | field_length = 65535; | |
| 10001 | 1790324 | break; | |
| 10002 | 140 | case MYSQL_TYPE_TINY_BLOB: | |
| 10003 | 140 | field_length = 255; | |
| 10004 | 140 | break; | |
| 10005 | 199076 | case MYSQL_TYPE_MEDIUM_BLOB: | |
| 10006 | 199076 | field_length = 16777215; | |
| 10007 | 199076 | break; | |
| 10008 | 50776 | case MYSQL_TYPE_LONG_BLOB: | |
| 10009 | 50776 | field_length = 4294967295; | |
| 10010 | 50776 | break; | |
| 10011 | 8076475 | case MYSQL_TYPE_ENUM: | |
| 10012 | case MYSQL_TYPE_SET: | ||
| 10013 | case MYSQL_TYPE_VAR_STRING: | ||
| 10014 | case MYSQL_TYPE_VARCHAR: | ||
| 10015 | case MYSQL_TYPE_STRING: | ||
| 10016 | 8076475 | break; | |
| 10017 | ✗ | default: | |
| 10018 | ✗ | break; | |
| 10019 | } | ||
| 10020 | |||
| 10021 |
4/4✓ Branch 0 taken 5058402 times.
✓ Branch 1 taken 5058389 times.
✓ Branch 2 taken 5057958 times.
✓ Branch 3 taken 444 times.
|
10116791 | if (!flag && field_length) { |
| 10022 |
2/2✓ Branch 0 taken 1020158 times.
✓ Branch 1 taken 4037800 times.
|
5057958 | if (blob_flag) |
| 10023 | 1020158 | return field_length / cs->mbminlen; | |
| 10024 | else | ||
| 10025 | 4037800 | return field_length / cs->mbmaxlen; | |
| 10026 |
4/4✓ Branch 0 taken 5058389 times.
✓ Branch 1 taken 444 times.
✓ Branch 2 taken 5057945 times.
✓ Branch 3 taken 444 times.
|
5058833 | } else if (flag && field_length) { |
| 10027 | 5057945 | return field_length; | |
| 10028 | } | ||
| 10029 | |||
| 10030 | 888 | return 0; | |
| 10031 | 16067029 | } | |
| 10032 | |||
| 10033 | 1956501 | longlong Item_func_internal_get_view_warning_or_error::val_int() { | |
| 10034 |
1/2✓ Branch 0 taken 1956501 times.
✗ Branch 1 not taken.
|
1956501 | DBUG_TRACE; |
| 10035 | |||
| 10036 | 1956501 | String schema_name; | |
| 10037 | 1956501 | String table_name; | |
| 10038 | 1956501 | String table_type; | |
| 10039 |
1/2✓ Branch 0 taken 1956501 times.
✗ Branch 1 not taken.
|
1956501 | String *schema_name_ptr = args[0]->val_str(&schema_name); |
| 10040 |
1/2✓ Branch 0 taken 1956501 times.
✗ Branch 1 not taken.
|
1956501 | String *table_name_ptr = args[1]->val_str(&table_name); |
| 10041 |
1/2✓ Branch 0 taken 1956501 times.
✗ Branch 1 not taken.
|
1956501 | String *table_type_ptr = args[2]->val_str(&table_type); |
| 10042 | |||
| 10043 |
4/6✓ Branch 0 taken 1956500 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1956500 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1956500 times.
|
1956501 | if (table_type_ptr == nullptr || schema_name_ptr == nullptr || |
| 10044 | table_name_ptr == nullptr) { | ||
| 10045 | 1 | return 0; | |
| 10046 | } | ||
| 10047 | |||
| 10048 | 1956500 | String options; | |
| 10049 |
1/2✓ Branch 0 taken 1956500 times.
✗ Branch 1 not taken.
|
1956500 | String *options_ptr = args[3]->val_str(&options); |
| 10050 |
6/8✓ Branch 0 taken 1956500 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16006 times.
✓ Branch 3 taken 1940494 times.
✓ Branch 4 taken 16006 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 16006 times.
✓ Branch 7 taken 1940494 times.
|
1956500 | if (strcmp(table_type_ptr->c_ptr_safe(), "VIEW") == 0 && |
| 10051 | options_ptr != nullptr) { | ||
| 10052 | 16006 | bool is_view_valid = true; | |
| 10053 | std::unique_ptr<dd::Properties> view_options( | ||
| 10054 |
3/6✓ Branch 0 taken 16006 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16006 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 16006 times.
✗ Branch 5 not taken.
|
16006 | dd::Properties::parse_properties(options_ptr->c_ptr_safe())); |
| 10055 | |||
| 10056 | // Warn if the property string is corrupt. | ||
| 10057 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16006 times.
|
16006 | if (!view_options.get()) { |
| 10058 | ✗ | LogErr(WARNING_LEVEL, ER_WARN_PROPERTY_STRING_PARSE_FAILED, | |
| 10059 | options_ptr->c_ptr_safe()); | ||
| 10060 | ✗ | assert(false); | |
| 10061 | return 0; | ||
| 10062 | } | ||
| 10063 | |||
| 10064 | // Return 0 if get_bool() or push_view_warning_or_error() fails | ||
| 10065 |
3/6✓ Branch 0 taken 16006 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16006 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 16006 times.
|
16006 | if (view_options->get("view_valid", &is_view_valid)) return 0; |
| 10066 | |||
| 10067 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 15991 times.
|
16006 | if (is_view_valid == false) { |
| 10068 |
2/4✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
|
15 | push_view_warning_or_error(current_thd, schema_name_ptr->c_ptr_safe(), |
| 10069 |
2/4✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
|
15 | table_name_ptr->c_ptr_safe()); |
| 10070 | 15 | return 0; | |
| 10071 | } | ||
| 10072 |
2/2✓ Branch 0 taken 15991 times.
✓ Branch 1 taken 15 times.
|
16006 | } |
| 10073 | |||
| 10074 | 1956485 | return 1; | |
| 10075 | 1956501 | } | |
| 10076 | |||
| 10077 | /** | ||
| 10078 | @brief | ||
| 10079 | INFORMATION_SCHEMA picks metadata from DD using system views. | ||
| 10080 | INFORMATION_SCHEMA.STATISTICS.SUB_PART represents index sub part length. | ||
| 10081 | This internal function is used to get index sub part length. | ||
| 10082 | |||
| 10083 | Syntax: | ||
| 10084 | int GET_DD_INDEX_SUB_PART_LENGTH( | ||
| 10085 | index_column_usage_length, | ||
| 10086 | column_type, | ||
| 10087 | column_length, | ||
| 10088 | column_collation_id, | ||
| 10089 | index_type); | ||
| 10090 | |||
| 10091 | @returns Index sub part length. | ||
| 10092 | */ | ||
| 10093 | 3243 | longlong Item_func_get_dd_index_sub_part_length::val_int() { | |
| 10094 |
1/2✓ Branch 0 taken 3243 times.
✗ Branch 1 not taken.
|
3243 | DBUG_TRACE; |
| 10095 | 3243 | null_value = true; | |
| 10096 | |||
| 10097 | // Read arguments | ||
| 10098 |
1/2✓ Branch 0 taken 3243 times.
✗ Branch 1 not taken.
|
3243 | uint key_part_length = args[0]->val_int(); |
| 10099 | dd::enum_column_types col_type = | ||
| 10100 |
1/2✓ Branch 0 taken 3243 times.
✗ Branch 1 not taken.
|
3243 | static_cast<dd::enum_column_types>(args[1]->val_int()); |
| 10101 |
1/2✓ Branch 0 taken 3243 times.
✗ Branch 1 not taken.
|
3243 | uint column_length = args[2]->val_int(); |
| 10102 |
1/2✓ Branch 0 taken 3243 times.
✗ Branch 1 not taken.
|
3243 | uint csid = args[3]->val_int(); |
| 10103 | dd::Index::enum_index_type idx_type = | ||
| 10104 |
1/2✓ Branch 0 taken 3243 times.
✗ Branch 1 not taken.
|
3243 | static_cast<dd::Index::enum_index_type>(args[4]->val_int()); |
| 10105 |
4/6✓ Branch 0 taken 3237 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 3237 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3237 times.
✗ Branch 5 not taken.
|
3243 | if (args[0]->null_value || args[1]->null_value || args[2]->null_value || |
| 10106 |
2/4✓ Branch 0 taken 3237 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3237 times.
|
3237 | args[3]->null_value || args[4]->null_value) |
| 10107 | 6 | return 0; | |
| 10108 | |||
| 10109 | // Read server col_type and check if we have key part. | ||
| 10110 |
1/2✓ Branch 0 taken 3237 times.
✗ Branch 1 not taken.
|
3237 | enum_field_types field_type = dd_get_old_field_type(col_type); |
| 10111 |
3/4✓ Branch 0 taken 3237 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1722 times.
✓ Branch 3 taken 1515 times.
|
3237 | if (!Field::type_can_have_key_part(field_type)) return 0; |
| 10112 | |||
| 10113 | // Calculate the key length for the column. Note that we pass inn dummy values | ||
| 10114 | // for "decimals", "is_unsigned" and "elements" since none of those arguments | ||
| 10115 | // will affect the key length for any of the data types that can have a prefix | ||
| 10116 | // index (see Field::type_can_have_key_part above). | ||
| 10117 | uint32 column_key_length = | ||
| 10118 |
1/2✓ Branch 0 taken 1515 times.
✗ Branch 1 not taken.
|
1515 | calc_key_length(field_type, column_length, 0, false, 0); |
| 10119 | |||
| 10120 | // Read column charset id from args[3] | ||
| 10121 | 1515 | const CHARSET_INFO *column_charset = &my_charset_latin1; | |
| 10122 |
1/2✓ Branch 0 taken 1515 times.
✗ Branch 1 not taken.
|
1515 | if (csid) { |
| 10123 |
1/2✓ Branch 0 taken 1515 times.
✗ Branch 1 not taken.
|
1515 | column_charset = get_charset(csid, MYF(0)); |
| 10124 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1515 times.
|
1515 | assert(column_charset); |
| 10125 | } | ||
| 10126 | |||
| 10127 |
4/4✓ Branch 0 taken 1483 times.
✓ Branch 1 taken 32 times.
✓ Branch 2 taken 190 times.
✓ Branch 3 taken 1293 times.
|
1515 | if ((idx_type != dd::Index::IT_FULLTEXT) && |
| 10128 | (key_part_length != column_key_length)) { | ||
| 10129 | 190 | longlong sub_part_length = key_part_length / column_charset->mbmaxlen; | |
| 10130 | 190 | null_value = false; | |
| 10131 | 190 | return sub_part_length; | |
| 10132 | } | ||
| 10133 | |||
| 10134 | 1325 | return 0; | |
| 10135 | 3243 | } | |
| 10136 | |||
| 10137 | /** | ||
| 10138 | @brief | ||
| 10139 | Internal function used by INFORMATION_SCHEMA implementation to check | ||
| 10140 | if a role is a mandatory role. | ||
| 10141 | |||
| 10142 | Syntax: | ||
| 10143 | int INTERNAL_IS_MANDATORY_ROLE(role_user, role_host); | ||
| 10144 | |||
| 10145 | @returns, | ||
| 10146 | 1 - If the role is mandatory. | ||
| 10147 | 0 - If not. | ||
| 10148 | */ | ||
| 10149 | |||
| 10150 | 156 | longlong Item_func_internal_is_mandatory_role::val_int() { | |
| 10151 |
1/2✓ Branch 0 taken 156 times.
✗ Branch 1 not taken.
|
156 | DBUG_TRACE; |
| 10152 | |||
| 10153 | // Read schema_name | ||
| 10154 | 156 | String role_name; | |
| 10155 |
1/2✓ Branch 0 taken 156 times.
✗ Branch 1 not taken.
|
156 | String *role_name_ptr = args[0]->val_str(&role_name); |
| 10156 | 156 | String role_host; | |
| 10157 |
1/2✓ Branch 0 taken 156 times.
✗ Branch 1 not taken.
|
156 | String *role_host_ptr = args[1]->val_str(&role_host); |
| 10158 |
3/4✓ Branch 0 taken 155 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 155 times.
|
156 | if (role_name_ptr == nullptr || role_host_ptr == nullptr) { |
| 10159 | 1 | null_value = true; | |
| 10160 | 1 | return 0; | |
| 10161 | } | ||
| 10162 | |||
| 10163 | // Create Auth_id for ID being searched. | ||
| 10164 | LEX_CSTRING lex_user; | ||
| 10165 |
1/2✓ Branch 0 taken 155 times.
✗ Branch 1 not taken.
|
155 | lex_user.str = role_name_ptr->c_ptr_safe(); |
| 10166 | 155 | lex_user.length = role_name_ptr->length(); | |
| 10167 | |||
| 10168 | LEX_CSTRING lex_host; | ||
| 10169 |
1/2✓ Branch 0 taken 155 times.
✗ Branch 1 not taken.
|
155 | lex_host.str = role_host_ptr->c_ptr_safe(); |
| 10170 | 155 | lex_host.length = role_host_ptr->length(); | |
| 10171 | |||
| 10172 | 155 | bool is_mandatory{false}; | |
| 10173 |
3/4✓ Branch 0 taken 155 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 154 times.
|
155 | if (is_mandatory_role(lex_user, lex_host, &is_mandatory)) { |
| 10174 | 4 | push_warning_printf( | |
| 10175 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | current_thd, Sql_condition::SL_WARNING, |
| 10176 | ER_FAILED_TO_DETERMINE_IF_ROLE_IS_MANDATORY, | ||
| 10177 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | ER_THD(current_thd, ER_FAILED_TO_DETERMINE_IF_ROLE_IS_MANDATORY), |
| 10178 | lex_user.str, lex_host.str); | ||
| 10179 | } | ||
| 10180 | |||
| 10181 | 155 | return is_mandatory; | |
| 10182 | 156 | } | |
| 10183 | |||
| 10184 | /** | ||
| 10185 | @brief | ||
| 10186 | Internal function used by INFORMATION_SCHEMA implementation to check | ||
| 10187 | if a role enabled. | ||
| 10188 | |||
| 10189 | Syntax: | ||
| 10190 | int INTERNAL_IS_ENABLED_ROLE(role_user, role_host); | ||
| 10191 | |||
| 10192 | @returns, | ||
| 10193 | 1 - If the role is enabled. | ||
| 10194 | 0 - If not. | ||
| 10195 | */ | ||
| 10196 | |||
| 10197 | 436 | longlong Item_func_internal_is_enabled_role::val_int() { | |
| 10198 |
1/2✓ Branch 0 taken 436 times.
✗ Branch 1 not taken.
|
436 | DBUG_TRACE; |
| 10199 |
1/2✓ Branch 0 taken 436 times.
✗ Branch 1 not taken.
|
436 | THD *thd = current_thd; |
| 10200 | |||
| 10201 | // Read schema_name | ||
| 10202 | 436 | String role_name; | |
| 10203 |
1/2✓ Branch 0 taken 436 times.
✗ Branch 1 not taken.
|
436 | String *role_name_ptr = args[0]->val_str(&role_name); |
| 10204 | 436 | String role_host; | |
| 10205 |
1/2✓ Branch 0 taken 436 times.
✗ Branch 1 not taken.
|
436 | String *role_host_ptr = args[1]->val_str(&role_host); |
| 10206 |
3/4✓ Branch 0 taken 435 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 435 times.
|
436 | if (role_name_ptr == nullptr || role_host_ptr == nullptr) { |
| 10207 | 1 | null_value = true; | |
| 10208 | 1 | return 0; | |
| 10209 | } | ||
| 10210 | |||
| 10211 |
3/4✓ Branch 0 taken 435 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 199 times.
✓ Branch 3 taken 236 times.
|
435 | if (thd->m_main_security_ctx.get_active_roles()->size() == 0) return 0; |
| 10212 | |||
| 10213 | // Create Auth_id for ID being searched. | ||
| 10214 | LEX_CSTRING lex_user; | ||
| 10215 |
1/2✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
|
236 | lex_user.str = role_name_ptr->c_ptr_safe(); |
| 10216 | 236 | lex_user.length = role_name_ptr->length(); | |
| 10217 | |||
| 10218 | LEX_CSTRING lex_host; | ||
| 10219 |
1/2✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
|
236 | lex_host.str = role_host_ptr->c_ptr_safe(); |
| 10220 | 236 | lex_host.length = role_host_ptr->length(); | |
| 10221 | |||
| 10222 | // Match the ID and return true if found. | ||
| 10223 |
3/4✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 241 times.
✓ Branch 3 taken 185 times.
|
426 | for (auto &rid : *thd->m_main_security_ctx.get_active_roles()) { |
| 10224 |
4/6✓ Branch 0 taken 241 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 241 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 51 times.
✓ Branch 5 taken 190 times.
|
241 | if (rid == std::make_pair(lex_user, lex_host)) return 1; |
| 10225 | } | ||
| 10226 | |||
| 10227 | 185 | return 0; | |
| 10228 | 436 | } | |
| 10229 |